Use consistent terminology for lifted operators

ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj

@@ -95,7 +95,7 @@
     <Compile Include="FlowAnalysis\SsaOptimization.cs" />
     <Compile Include="FlowAnalysis\SsaVariable.cs" />
     <Compile Include="FlowAnalysis\TransformToSsa.cs" />
-    <Compile Include="ILAst\NullableOperators.cs" />
+    <Compile Include="ILAst\LiftedOperators.cs" />
     <Compile Include="ILAst\InitializerPeepholeTransforms.cs" />
     <Compile Include="ILAst\DefaultDictionary.cs" />
     <Compile Include="ILAst\GotoRemoval.cs" />

ICSharpCode.Decompiler/ILAst/ILAstOptimizer.cs

@@ -47,7 +47,7 @@ namespace ICSharpCode.Decompiler.ILAst
 		TransformDecimalCtorToConstant,
 		SimplifyLdObjAndStObj,
 		SimplifyCustomShortCircuit,
-		SimplifyNullableOperators,
+		SimplifyLiftedOperators,
 		TransformArrayInitializers,
 		TransformMultidimensionalArrayInitializers,
 		TransformObjectInitializers,
@@ -152,8 +152,8 @@ namespace ICSharpCode.Decompiler.ILAst
 					if (abortBeforeStep == ILAstOptimizationStep.SimplifyCustomShortCircuit) return;
 					modified |= block.RunOptimization(new SimpleControlFlow(context, method).SimplifyCustomShortCircuit);
 
-					if (abortBeforeStep == ILAstOptimizationStep.SimplifyNullableOperators) return;
+					if (abortBeforeStep == ILAstOptimizationStep.SimplifyLiftedOperators) return;
-					modified |= block.RunOptimization(SimplifyNullableOperators);
+					modified |= block.RunOptimization(SimplifyLiftedOperators);
 					
 					if (abortBeforeStep == ILAstOptimizationStep.TransformArrayInitializers) return;
 					modified |= block.RunOptimization(TransformArrayInitializers);

ICSharpCode.Decompiler/ILAst/ILCodes.cs

@@ -317,7 +317,7 @@ namespace ICSharpCode.Decompiler.ILAst
 		/// Also used when inlining a method call on a value type: "stloc(v, ...); call(M, ldloca(v));" becomes "call(M, AddressOf(...))"
 		/// </remarks>
 		AddressOf,
-		/// <summary>Simulates getting the value of the nullable argument in comparisons involving nullable values</summary>
+		/// <summary>Simulates getting the value of a lifted operator's nullable argument</summary>
 		/// <remarks>
 		/// For example "stloc(v1, ...); stloc(v2, ...); logicand(ceq(call(Nullable`1::GetValueOrDefault, ldloca(v1)), ldloc(v2)), callgetter(Nullable`1::get_HasValue, ldloca(v1)))" becomes "wrap(ceq(ValueOf(...), ...))"
 		/// </remarks>

ICSharpCode.Decompiler/ILAst/LiftedOperators.cs

@@ -26,9 +26,9 @@ namespace ICSharpCode.Decompiler.ILAst
 {
 	partial class ILAstOptimizer
 	{
-		bool SimplifyNullableOperators(List<ILNode> body, ILExpression expr, int pos)
+		bool SimplifyLiftedOperators(List<ILNode> body, ILExpression expr, int pos)
 		{
-			if (!new PatternMatcher(typeSystem).SimplifyNullableOperators(expr)) return false;
+			if (!new PatternMatcher(typeSystem).SimplifyLiftedOperators(expr)) return false;
 
 			var inlining = new ILInlining(method);
 			while (--pos >= 0 && inlining.InlineIfPossible(body, ref pos)) ;
@@ -44,13 +44,13 @@ namespace ICSharpCode.Decompiler.ILAst
 				this.typeSystem = typeSystem;
 			}
 
-			public bool SimplifyNullableOperators(ILExpression expr)
+			public bool SimplifyLiftedOperators(ILExpression expr)
 			{
 				if (Simplify(expr)) return true;
 
 				bool modified = false;
 				foreach (var a in expr.Arguments)
-					modified |= SimplifyNullableOperators(a);
+					modified |= SimplifyLiftedOperators(a);
 				return modified;
 			}
 

ICSharpCode.Decompiler/ILAst/PeepholeTransform.cs

@@ -397,17 +397,17 @@ namespace ICSharpCode.Decompiler.ILAst
 				return false;
 			
 			ILExpression op = expr.Arguments.Last();
-			// in case of compound assignments with nullable values the result is inside NullableOf and the operand is inside ValueOf
+			// in case of compound assignments with a lifted operator the result is inside NullableOf and the operand is inside ValueOf
-			bool nullable = false;
+			bool liftedOperator = false;
 			if (op.Code == ILCode.NullableOf) {
 				op = op.Arguments[0];
-				nullable = true;
+				liftedOperator = true;
 			}
 			if (!CanBeRepresentedAsCompoundAssignment(op))
 				return false;
 
 			ILExpression ldelem = op.Arguments[0];
-			if (nullable) {
+			if (liftedOperator) {
 				if (ldelem.Code != ILCode.ValueOf)
 					return false;
 				ldelem = ldelem.Arguments[0];

ICSharpCode.Decompiler/Tests/ICSharpCode.Decompiler.Tests.csproj

@@ -64,7 +64,7 @@
   <ItemGroup>
     <Compile Include="CallOverloadedMethod.cs" />
     <Compile Include="CheckedUnchecked.cs" />
-    <Compile Include="NullableOperators.cs" />
+    <Compile Include="LiftedOperators.cs" />
     <Compile Include="CustomShortCircuitOperators.cs" />
     <Compile Include="Helpers\CodeAssert.cs" />
     <Compile Include="IncrementDecrement.cs" />

ICSharpCode.Decompiler/Tests/LiftedOperators.cs

@@ -19,9 +19,9 @@
 using System;
 using System.Runtime.InteropServices;
 
-public static class NullableOperators
+public static class LiftedOperators
 {
-	// C# uses 4 different patterns of IL for operators involving nullable values: bool, other primitive types, decimal, other structs.
+	// C# uses 4 different patterns of IL for lifted operators: bool, other primitive types, decimal, other structs.
 	// Different patterns are used depending on whether both of the operands are nullable or only the left/right operand is nullable.
 	// Negation must not be pushed through such comparisons because it would change the semantics.
 	// A comparison used in a condition differs somewhat from a comparison used as a simple value.
@@ -131,7 +131,7 @@ public static class NullableOperators
 		a ^= b;
 	}
 
-	public static void BoolValueComplex(bool? a, Func<bool> x, bool?[] list)
+	public static void BoolValueComplex(bool? a, Func<bool> x)
 	{
 		Console.WriteLine(a == x());
 		Console.WriteLine(a != x());
@@ -151,7 +151,7 @@ public static class NullableOperators
 		a ^= x();
 
 		Console.WriteLine(x() ^ a);
-		list[0] ^= x();
+		(new bool?[0])[0] ^= x();
 	}
 
 	public static void BoolValueConst(bool? a)
@@ -316,7 +316,7 @@ public static class NullableOperators
 		a >>= b;
 	}
 
-	public static void IntValueComplex(int? a, Func<int> x, int?[] list)
+	public static void IntValueComplex(int? a, Func<int> x)
 	{
 		Console.WriteLine(a == x());
 		Console.WriteLine(a != x());
@@ -349,7 +349,7 @@ public static class NullableOperators
 		a >>= x();
 
 		Console.WriteLine(x() + a);
-		list[0] += x();
+		(new int?[0])[0] += x();
 	}
 
 	public static void IntValueConst(int? a)
@@ -515,7 +515,7 @@ public static class NullableOperators
 		a %= b;
 	}
 
-	public static void NumberValueComplex(decimal? a, Func<decimal> x, decimal?[] list)
+	public static void NumberValueComplex(decimal? a, Func<decimal> x)
 	{
 		Console.WriteLine(a == x());
 		Console.WriteLine(a != x());
@@ -538,7 +538,7 @@ public static class NullableOperators
 		a %= x();
 
 		Console.WriteLine(x() + a);
-		list[0] += x();
+		(new decimal?[0])[0] += x();
 	}
 
 	public static void NumberValueConst(decimal? a)
@@ -679,7 +679,7 @@ public static class NullableOperators
 		a >>= i;
 	}
 
-	public static void StructValueComplex(TS? a, Func<TS> x, Func<int> i, TS?[] list)
+	public static void StructValueComplex(TS? a, Func<TS> x, Func<int> i)
 	{
 		Console.WriteLine(a == x());
 		Console.WriteLine(a != x());
@@ -712,7 +712,7 @@ public static class NullableOperators
 		a >>= i();
 
 		Console.WriteLine(x() + a);
-		list[0] += x();
+		(new TS?[0])[0] += x();
 	}
 }
 

ICSharpCode.Decompiler/Tests/TestRunner.cs

@@ -83,21 +83,21 @@ namespace ICSharpCode.Decompiler.Tests
 		}
 
 		[Test]
-		public void Loops()
+		public void LiftedOperators()
 		{
-			TestFile(@"..\..\Tests\Loops.cs");
+			TestFile(@"..\..\Tests\LiftedOperators.cs");
 		}
 		
 		[Test]
-		public void MultidimensionalArray()
+		public void Loops()
 		{
-			TestFile(@"..\..\Tests\MultidimensionalArray.cs");
+			TestFile(@"..\..\Tests\Loops.cs");
 		}
 		
 		[Test]
-		public void NullableOperators()
+		public void MultidimensionalArray()
 		{
-			TestFile(@"..\..\Tests\NullableOperators.cs");
+			TestFile(@"..\..\Tests\MultidimensionalArray.cs");
 		}
 		
 		[Test]