From 572efeb367ec9f89a229c3e5b6bc14efea3ba64d Mon Sep 17 00:00:00 2001 From: Bart De Smet Date: Wed, 26 Oct 2016 12:04:23 -0700 Subject: [PATCH] Using named parameter syntax when passing literals --- .../Linq/Expressions/Compiler/AssemblyGen.cs | 2 +- .../Linq/Expressions/BinaryExpression.cs | 214 +++++++++--------- .../src/System/Linq/Expressions/CatchBlock.cs | 4 +- .../Expressions/Compiler/HoistedLocals.cs | 2 +- .../Compiler/LambdaCompiler.Address.cs | 6 +- .../Compiler/LambdaCompiler.Binary.cs | 10 +- .../Compiler/LambdaCompiler.Expressions.cs | 14 +- .../Compiler/LambdaCompiler.Logical.cs | 4 +- .../Compiler/LambdaCompiler.Statements.cs | 2 +- .../Compiler/LambdaCompiler.Unary.cs | 8 +- .../src/System/Linq/Expressions/Expression.cs | 2 +- .../Linq/Expressions/IndexExpression.cs | 8 +- .../Interpreter/FieldOperations.cs | 2 +- .../Interpreter/InstructionList.cs | 2 +- .../Expressions/Interpreter/LightCompiler.cs | 68 +++--- .../Interpreter/LightDelegateCreator.cs | 2 +- .../Linq/Expressions/LabelExpression.cs | 4 +- .../System/Linq/Expressions/LabelTarget.cs | 4 +- .../Linq/Expressions/ListInitExpression.cs | 2 +- .../System/Linq/Expressions/LoopExpression.cs | 4 +- .../Linq/Expressions/MemberExpression.cs | 8 +- .../Linq/Expressions/MemberInitExpression.cs | 10 +- .../Linq/Expressions/ParameterExpression.cs | 6 +- .../System/Linq/Expressions/TryExpression.cs | 4 +- .../Linq/Expressions/TypeBinaryExpression.cs | 6 +- .../Linq/Expressions/UnaryExpression.cs | 48 ++-- .../ReadOnlyCollectionBuilder.cs | 2 +- 27 files changed, 224 insertions(+), 224 deletions(-) diff --git a/src/Common/src/System/Linq/Expressions/Compiler/AssemblyGen.cs b/src/Common/src/System/Linq/Expressions/Compiler/AssemblyGen.cs index 4e6a71cb5716..91ad27b958a5 100644 --- a/src/Common/src/System/Linq/Expressions/Compiler/AssemblyGen.cs +++ b/src/Common/src/System/Linq/Expressions/Compiler/AssemblyGen.cs @@ -26,7 +26,7 @@ private static AssemblyGen Assembly { if (s_assembly == null) { - Interlocked.CompareExchange(ref s_assembly, new AssemblyGen(), null); + Interlocked.CompareExchange(ref s_assembly, new AssemblyGen(), comparand: null); } return s_assembly; } diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/BinaryExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/BinaryExpression.cs index 763788f38ffb..1bc0871430f1 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/BinaryExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/BinaryExpression.cs @@ -842,7 +842,7 @@ private static bool IsValidLiftedConditionalLogicalOperator(Type left, Type righ /// The BinaryExpression that results from calling the appropriate factory method. public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right) { - return MakeBinary(binaryType, left, right, false, null, null); + return MakeBinary(binaryType, left, right, liftToNull: false, method: null, conversion: null); } /// @@ -856,7 +856,7 @@ public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression /// The BinaryExpression that results from calling the appropriate factory method. public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression left, Expression right, bool liftToNull, MethodInfo method) { - return MakeBinary(binaryType, left, right, liftToNull, method, null); + return MakeBinary(binaryType, left, right, liftToNull, method, conversion: null); } /// @@ -969,7 +969,7 @@ public static BinaryExpression MakeBinary(ExpressionType binaryType, Expression /// and the and properties set to the specified values. public static BinaryExpression Equal(Expression left, Expression right) { - return Equal(left, right, false, null); + return Equal(left, right, liftToNull: false, method: null); } /// @@ -1021,7 +1021,7 @@ public static BinaryExpression ReferenceEqual(Expression left, Expression right) /// and the and properties set to the specified values. public static BinaryExpression NotEqual(Expression left, Expression right) { - return NotEqual(left, right, false, null); + return NotEqual(left, right, liftToNull: false, method: null); } /// @@ -1114,7 +1114,7 @@ private static BinaryExpression GetEqualityComparisonOperator(ExpressionType bin /// and the and properties set to the specified values. public static BinaryExpression GreaterThan(Expression left, Expression right) { - return GreaterThan(left, right, false, null); + return GreaterThan(left, right, liftToNull: false, method: null); } /// @@ -1148,7 +1148,7 @@ public static BinaryExpression GreaterThan(Expression left, Expression right, bo public static BinaryExpression LessThan(Expression left, Expression right) { - return LessThan(left, right, false, null); + return LessThan(left, right, liftToNull: false, method: null); } /// @@ -1181,7 +1181,7 @@ public static BinaryExpression LessThan(Expression left, Expression right, bool /// and the and properties set to the specified values. public static BinaryExpression GreaterThanOrEqual(Expression left, Expression right) { - return GreaterThanOrEqual(left, right, false, null); + return GreaterThanOrEqual(left, right, liftToNull: false, method: null); } /// @@ -1214,7 +1214,7 @@ public static BinaryExpression GreaterThanOrEqual(Expression left, Expression ri /// and the and properties set to the specified values. public static BinaryExpression LessThanOrEqual(Expression left, Expression right) { - return LessThanOrEqual(left, right, false, null); + return LessThanOrEqual(left, right, liftToNull: false, method: null); } /// @@ -1267,7 +1267,7 @@ private static BinaryExpression GetComparisonOperator(ExpressionType binaryType, /// and the and properties set to the specified values. public static BinaryExpression AndAlso(Expression left, Expression right) { - return AndAlso(left, right, null); + return AndAlso(left, right, method: null); } /// @@ -1320,7 +1320,7 @@ public static BinaryExpression AndAlso(Expression left, Expression right, Method /// and the and properties set to the specified values. public static BinaryExpression OrElse(Expression left, Expression right) { - return OrElse(left, right, null); + return OrElse(left, right, method: null); } /// @@ -1377,7 +1377,7 @@ public static BinaryExpression OrElse(Expression left, Expression right, MethodI /// and the and properties set to the specified values. public static BinaryExpression Coalesce(Expression left, Expression right) { - return Coalesce(left, right, null); + return Coalesce(left, right, conversion: null); } /// @@ -1476,7 +1476,7 @@ private static Type ValidateCoalesceArgTypes(Type left, Type right) /// and the and properties set to the specified values. public static BinaryExpression Add(Expression left, Expression right) { - return Add(left, right, null); + return Add(left, right, method: null); } /// @@ -1498,9 +1498,9 @@ public static BinaryExpression Add(Expression left, Expression right, MethodInfo { return new SimpleBinaryExpression(ExpressionType.Add, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Add, "op_Addition", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Add, "op_Addition", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.Add, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.Add, left, right, method, liftToNull: true); } /// @@ -1512,7 +1512,7 @@ public static BinaryExpression Add(Expression left, Expression right, MethodInfo /// and the and properties set to the specified values. public static BinaryExpression AddAssign(Expression left, Expression right) { - return AddAssign(left, right, null, null); + return AddAssign(left, right, method: null, conversion: null); } /// @@ -1526,7 +1526,7 @@ public static BinaryExpression AddAssign(Expression left, Expression right) /// public static BinaryExpression AddAssign(Expression left, Expression right, MethodInfo method) { - return AddAssign(left, right, method, null); + return AddAssign(left, right, method, conversion: null); } /// @@ -1556,9 +1556,9 @@ public static BinaryExpression AddAssign(Expression left, Expression right, Meth } return new SimpleBinaryExpression(ExpressionType.AddAssign, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.AddAssign, "op_Addition", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.AddAssign, "op_Addition", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.AddAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.AddAssign, left, right, method, conversion, liftToNull: true); } private static void ValidateOpAssignConversionLambda(LambdaExpression conversion, Expression left, MethodInfo method, ExpressionType nodeType) @@ -1597,7 +1597,7 @@ private static void ValidateOpAssignConversionLambda(LambdaExpression conversion /// public static BinaryExpression AddAssignChecked(Expression left, Expression right) { - return AddAssignChecked(left, right, null); + return AddAssignChecked(left, right, method: null); } /// @@ -1611,7 +1611,7 @@ public static BinaryExpression AddAssignChecked(Expression left, Expression righ /// public static BinaryExpression AddAssignChecked(Expression left, Expression right, MethodInfo method) { - return AddAssignChecked(left, right, method, null); + return AddAssignChecked(left, right, method, conversion: null); } /// @@ -1642,9 +1642,9 @@ public static BinaryExpression AddAssignChecked(Expression left, Expression righ } return new SimpleBinaryExpression(ExpressionType.AddAssignChecked, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.AddAssignChecked, "op_Addition", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.AddAssignChecked, "op_Addition", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.AddAssignChecked, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.AddAssignChecked, left, right, method, conversion, liftToNull: true); } /// @@ -1656,7 +1656,7 @@ public static BinaryExpression AddAssignChecked(Expression left, Expression righ /// and the and properties set to the specified values. public static BinaryExpression AddChecked(Expression left, Expression right) { - return AddChecked(left, right, null); + return AddChecked(left, right, method: null); } /// @@ -1678,9 +1678,9 @@ public static BinaryExpression AddChecked(Expression left, Expression right, Met { return new SimpleBinaryExpression(ExpressionType.AddChecked, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.AddChecked, "op_Addition", left, right, false); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.AddChecked, "op_Addition", left, right, liftToNull: false); } - return GetMethodBasedBinaryOperator(ExpressionType.AddChecked, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.AddChecked, left, right, method, liftToNull: true); } /// @@ -1692,7 +1692,7 @@ public static BinaryExpression AddChecked(Expression left, Expression right, Met /// and the and properties set to the specified values. public static BinaryExpression Subtract(Expression left, Expression right) { - return Subtract(left, right, null); + return Subtract(left, right, method: null); } /// @@ -1714,9 +1714,9 @@ public static BinaryExpression Subtract(Expression left, Expression right, Metho { return new SimpleBinaryExpression(ExpressionType.Subtract, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Subtract, "op_Subtraction", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Subtract, "op_Subtraction", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.Subtract, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.Subtract, left, right, method, liftToNull: true); } /// @@ -1728,7 +1728,7 @@ public static BinaryExpression Subtract(Expression left, Expression right, Metho /// and the and properties set to the specified values. public static BinaryExpression SubtractAssign(Expression left, Expression right) { - return SubtractAssign(left, right, null, null); + return SubtractAssign(left, right, method: null, conversion: null); } /// @@ -1742,7 +1742,7 @@ public static BinaryExpression SubtractAssign(Expression left, Expression right) /// public static BinaryExpression SubtractAssign(Expression left, Expression right, MethodInfo method) { - return SubtractAssign(left, right, method, null); + return SubtractAssign(left, right, method, conversion: null); } /// @@ -1772,9 +1772,9 @@ public static BinaryExpression SubtractAssign(Expression left, Expression right, } return new SimpleBinaryExpression(ExpressionType.SubtractAssign, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.SubtractAssign, "op_Subtraction", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.SubtractAssign, "op_Subtraction", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.SubtractAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.SubtractAssign, left, right, method, conversion, liftToNull: true); } /// @@ -1786,7 +1786,7 @@ public static BinaryExpression SubtractAssign(Expression left, Expression right, /// and the and properties set to the specified values. public static BinaryExpression SubtractAssignChecked(Expression left, Expression right) { - return SubtractAssignChecked(left, right, null); + return SubtractAssignChecked(left, right, method: null); } /// @@ -1800,7 +1800,7 @@ public static BinaryExpression SubtractAssignChecked(Expression left, Expression /// public static BinaryExpression SubtractAssignChecked(Expression left, Expression right, MethodInfo method) { - return SubtractAssignChecked(left, right, method, null); + return SubtractAssignChecked(left, right, method, conversion: null); } /// @@ -1830,9 +1830,9 @@ public static BinaryExpression SubtractAssignChecked(Expression left, Expression } return new SimpleBinaryExpression(ExpressionType.SubtractAssignChecked, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.SubtractAssignChecked, "op_Subtraction", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.SubtractAssignChecked, "op_Subtraction", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.SubtractAssignChecked, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.SubtractAssignChecked, left, right, method, conversion, liftToNull: true); } /// @@ -1844,7 +1844,7 @@ public static BinaryExpression SubtractAssignChecked(Expression left, Expression /// and the and properties set to the specified values. public static BinaryExpression SubtractChecked(Expression left, Expression right) { - return SubtractChecked(left, right, null); + return SubtractChecked(left, right, method: null); } /// @@ -1866,9 +1866,9 @@ public static BinaryExpression SubtractChecked(Expression left, Expression right { return new SimpleBinaryExpression(ExpressionType.SubtractChecked, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.SubtractChecked, "op_Subtraction", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.SubtractChecked, "op_Subtraction", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.SubtractChecked, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.SubtractChecked, left, right, method, liftToNull: true); } /// @@ -1880,7 +1880,7 @@ public static BinaryExpression SubtractChecked(Expression left, Expression right /// and the and properties set to the specified values. public static BinaryExpression Divide(Expression left, Expression right) { - return Divide(left, right, null); + return Divide(left, right, method: null); } /// @@ -1902,9 +1902,9 @@ public static BinaryExpression Divide(Expression left, Expression right, MethodI { return new SimpleBinaryExpression(ExpressionType.Divide, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Divide, "op_Division", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Divide, "op_Division", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.Divide, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.Divide, left, right, method, liftToNull: true); } /// @@ -1916,7 +1916,7 @@ public static BinaryExpression Divide(Expression left, Expression right, MethodI /// and the and properties set to the specified values. public static BinaryExpression DivideAssign(Expression left, Expression right) { - return DivideAssign(left, right, null, null); + return DivideAssign(left, right, method: null, conversion: null); } /// @@ -1930,7 +1930,7 @@ public static BinaryExpression DivideAssign(Expression left, Expression right) /// public static BinaryExpression DivideAssign(Expression left, Expression right, MethodInfo method) { - return DivideAssign(left, right, method, null); + return DivideAssign(left, right, method, conversion: null); } /// @@ -1960,9 +1960,9 @@ public static BinaryExpression DivideAssign(Expression left, Expression right, M } return new SimpleBinaryExpression(ExpressionType.DivideAssign, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.DivideAssign, "op_Division", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.DivideAssign, "op_Division", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.DivideAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.DivideAssign, left, right, method, conversion, liftToNull: true); } /// @@ -1974,7 +1974,7 @@ public static BinaryExpression DivideAssign(Expression left, Expression right, M /// and the and properties set to the specified values. public static BinaryExpression Modulo(Expression left, Expression right) { - return Modulo(left, right, null); + return Modulo(left, right, method: null); } /// @@ -1996,9 +1996,9 @@ public static BinaryExpression Modulo(Expression left, Expression right, MethodI { return new SimpleBinaryExpression(ExpressionType.Modulo, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Modulo, "op_Modulus", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Modulo, "op_Modulus", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.Modulo, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.Modulo, left, right, method, liftToNull: true); } /// @@ -2010,7 +2010,7 @@ public static BinaryExpression Modulo(Expression left, Expression right, MethodI /// and the and properties set to the specified values. public static BinaryExpression ModuloAssign(Expression left, Expression right) { - return ModuloAssign(left, right, null, null); + return ModuloAssign(left, right, method: null, conversion: null); } /// @@ -2024,7 +2024,7 @@ public static BinaryExpression ModuloAssign(Expression left, Expression right) /// public static BinaryExpression ModuloAssign(Expression left, Expression right, MethodInfo method) { - return ModuloAssign(left, right, method, null); + return ModuloAssign(left, right, method, conversion: null); } /// @@ -2054,9 +2054,9 @@ public static BinaryExpression ModuloAssign(Expression left, Expression right, M } return new SimpleBinaryExpression(ExpressionType.ModuloAssign, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.ModuloAssign, "op_Modulus", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.ModuloAssign, "op_Modulus", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.ModuloAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.ModuloAssign, left, right, method, conversion, liftToNull: true); } /// @@ -2068,7 +2068,7 @@ public static BinaryExpression ModuloAssign(Expression left, Expression right, M /// and the and properties set to the specified values. public static BinaryExpression Multiply(Expression left, Expression right) { - return Multiply(left, right, null); + return Multiply(left, right, method: null); } /// @@ -2090,9 +2090,9 @@ public static BinaryExpression Multiply(Expression left, Expression right, Metho { return new SimpleBinaryExpression(ExpressionType.Multiply, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Multiply, "op_Multiply", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Multiply, "op_Multiply", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.Multiply, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.Multiply, left, right, method, liftToNull: true); } /// @@ -2104,7 +2104,7 @@ public static BinaryExpression Multiply(Expression left, Expression right, Metho /// and the and properties set to the specified values. public static BinaryExpression MultiplyAssign(Expression left, Expression right) { - return MultiplyAssign(left, right, null, null); + return MultiplyAssign(left, right, method: null, conversion: null); } /// @@ -2118,7 +2118,7 @@ public static BinaryExpression MultiplyAssign(Expression left, Expression right) /// public static BinaryExpression MultiplyAssign(Expression left, Expression right, MethodInfo method) { - return MultiplyAssign(left, right, method, null); + return MultiplyAssign(left, right, method, conversion: null); } /// @@ -2148,9 +2148,9 @@ public static BinaryExpression MultiplyAssign(Expression left, Expression right, } return new SimpleBinaryExpression(ExpressionType.MultiplyAssign, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.MultiplyAssign, "op_Multiply", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.MultiplyAssign, "op_Multiply", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.MultiplyAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.MultiplyAssign, left, right, method, conversion, liftToNull: true); } /// @@ -2162,7 +2162,7 @@ public static BinaryExpression MultiplyAssign(Expression left, Expression right, /// and the and properties set to the specified values. public static BinaryExpression MultiplyAssignChecked(Expression left, Expression right) { - return MultiplyAssignChecked(left, right, null); + return MultiplyAssignChecked(left, right, method: null); } /// @@ -2176,7 +2176,7 @@ public static BinaryExpression MultiplyAssignChecked(Expression left, Expression /// public static BinaryExpression MultiplyAssignChecked(Expression left, Expression right, MethodInfo method) { - return MultiplyAssignChecked(left, right, method, null); + return MultiplyAssignChecked(left, right, method, conversion: null); } /// @@ -2206,9 +2206,9 @@ public static BinaryExpression MultiplyAssignChecked(Expression left, Expression } return new SimpleBinaryExpression(ExpressionType.MultiplyAssignChecked, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.MultiplyAssignChecked, "op_Multiply", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.MultiplyAssignChecked, "op_Multiply", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.MultiplyAssignChecked, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.MultiplyAssignChecked, left, right, method, conversion, liftToNull: true); } /// @@ -2220,7 +2220,7 @@ public static BinaryExpression MultiplyAssignChecked(Expression left, Expression /// and the and properties set to the specified values. public static BinaryExpression MultiplyChecked(Expression left, Expression right) { - return MultiplyChecked(left, right, null); + return MultiplyChecked(left, right, method: null); } /// @@ -2242,9 +2242,9 @@ public static BinaryExpression MultiplyChecked(Expression left, Expression right { return new SimpleBinaryExpression(ExpressionType.MultiplyChecked, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.MultiplyChecked, "op_Multiply", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.MultiplyChecked, "op_Multiply", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.MultiplyChecked, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.MultiplyChecked, left, right, method, liftToNull: true); } private static bool IsSimpleShift(Type left, Type right) @@ -2272,7 +2272,7 @@ private static Type GetResultTypeOfShift(Type left, Type right) /// and the and properties set to the specified values. public static BinaryExpression LeftShift(Expression left, Expression right) { - return LeftShift(left, right, null); + return LeftShift(left, right, method: null); } /// @@ -2295,9 +2295,9 @@ public static BinaryExpression LeftShift(Expression left, Expression right, Meth Type resultType = GetResultTypeOfShift(left.Type, right.Type); return new SimpleBinaryExpression(ExpressionType.LeftShift, left, right, resultType); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.LeftShift, "op_LeftShift", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.LeftShift, "op_LeftShift", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.LeftShift, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.LeftShift, left, right, method, liftToNull: true); } /// @@ -2309,7 +2309,7 @@ public static BinaryExpression LeftShift(Expression left, Expression right, Meth /// and the and properties set to the specified values. public static BinaryExpression LeftShiftAssign(Expression left, Expression right) { - return LeftShiftAssign(left, right, null, null); + return LeftShiftAssign(left, right, method: null, conversion: null); } /// @@ -2323,7 +2323,7 @@ public static BinaryExpression LeftShiftAssign(Expression left, Expression right /// public static BinaryExpression LeftShiftAssign(Expression left, Expression right, MethodInfo method) { - return LeftShiftAssign(left, right, method, null); + return LeftShiftAssign(left, right, method, conversion: null); } /// @@ -2354,9 +2354,9 @@ public static BinaryExpression LeftShiftAssign(Expression left, Expression right Type resultType = GetResultTypeOfShift(left.Type, right.Type); return new SimpleBinaryExpression(ExpressionType.LeftShiftAssign, left, right, resultType); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.LeftShiftAssign, "op_LeftShift", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.LeftShiftAssign, "op_LeftShift", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.LeftShiftAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.LeftShiftAssign, left, right, method, conversion, liftToNull: true); } /// @@ -2368,7 +2368,7 @@ public static BinaryExpression LeftShiftAssign(Expression left, Expression right /// and the and properties set to the specified values. public static BinaryExpression RightShift(Expression left, Expression right) { - return RightShift(left, right, null); + return RightShift(left, right, method: null); } /// @@ -2391,9 +2391,9 @@ public static BinaryExpression RightShift(Expression left, Expression right, Met Type resultType = GetResultTypeOfShift(left.Type, right.Type); return new SimpleBinaryExpression(ExpressionType.RightShift, left, right, resultType); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.RightShift, "op_RightShift", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.RightShift, "op_RightShift", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.RightShift, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.RightShift, left, right, method, liftToNull: true); } /// @@ -2405,7 +2405,7 @@ public static BinaryExpression RightShift(Expression left, Expression right, Met /// and the and properties set to the specified values. public static BinaryExpression RightShiftAssign(Expression left, Expression right) { - return RightShiftAssign(left, right, null, null); + return RightShiftAssign(left, right, method: null, conversion: null); } /// @@ -2419,7 +2419,7 @@ public static BinaryExpression RightShiftAssign(Expression left, Expression righ /// public static BinaryExpression RightShiftAssign(Expression left, Expression right, MethodInfo method) { - return RightShiftAssign(left, right, method, null); + return RightShiftAssign(left, right, method, conversion: null); } /// @@ -2450,9 +2450,9 @@ public static BinaryExpression RightShiftAssign(Expression left, Expression righ Type resultType = GetResultTypeOfShift(left.Type, right.Type); return new SimpleBinaryExpression(ExpressionType.RightShiftAssign, left, right, resultType); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.RightShiftAssign, "op_RightShift", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.RightShiftAssign, "op_RightShift", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.RightShiftAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.RightShiftAssign, left, right, method, conversion, liftToNull: true); } /// @@ -2464,7 +2464,7 @@ public static BinaryExpression RightShiftAssign(Expression left, Expression righ /// and the and properties set to the specified values. public static BinaryExpression And(Expression left, Expression right) { - return And(left, right, null); + return And(left, right, method: null); } /// @@ -2486,9 +2486,9 @@ public static BinaryExpression And(Expression left, Expression right, MethodInfo { return new SimpleBinaryExpression(ExpressionType.And, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.And, "op_BitwiseAnd", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.And, "op_BitwiseAnd", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.And, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.And, left, right, method, liftToNull: true); } /// @@ -2500,7 +2500,7 @@ public static BinaryExpression And(Expression left, Expression right, MethodInfo /// and the and properties set to the specified values. public static BinaryExpression AndAssign(Expression left, Expression right) { - return AndAssign(left, right, null, null); + return AndAssign(left, right, method: null, conversion: null); } /// @@ -2514,7 +2514,7 @@ public static BinaryExpression AndAssign(Expression left, Expression right) /// public static BinaryExpression AndAssign(Expression left, Expression right, MethodInfo method) { - return AndAssign(left, right, method, null); + return AndAssign(left, right, method, conversion: null); } /// @@ -2544,9 +2544,9 @@ public static BinaryExpression AndAssign(Expression left, Expression right, Meth } return new SimpleBinaryExpression(ExpressionType.AndAssign, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.AndAssign, "op_BitwiseAnd", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.AndAssign, "op_BitwiseAnd", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.AndAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.AndAssign, left, right, method, conversion, liftToNull: true); } /// @@ -2558,7 +2558,7 @@ public static BinaryExpression AndAssign(Expression left, Expression right, Meth /// and the and properties set to the specified values. public static BinaryExpression Or(Expression left, Expression right) { - return Or(left, right, null); + return Or(left, right, method: null); } /// @@ -2580,9 +2580,9 @@ public static BinaryExpression Or(Expression left, Expression right, MethodInfo { return new SimpleBinaryExpression(ExpressionType.Or, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Or, "op_BitwiseOr", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.Or, "op_BitwiseOr", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.Or, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.Or, left, right, method, liftToNull: true); } /// @@ -2594,7 +2594,7 @@ public static BinaryExpression Or(Expression left, Expression right, MethodInfo /// and the and properties set to the specified values. public static BinaryExpression OrAssign(Expression left, Expression right) { - return OrAssign(left, right, null, null); + return OrAssign(left, right, method: null, conversion: null); } /// @@ -2608,7 +2608,7 @@ public static BinaryExpression OrAssign(Expression left, Expression right) /// public static BinaryExpression OrAssign(Expression left, Expression right, MethodInfo method) { - return OrAssign(left, right, method, null); + return OrAssign(left, right, method, conversion: null); } /// @@ -2638,9 +2638,9 @@ public static BinaryExpression OrAssign(Expression left, Expression right, Metho } return new SimpleBinaryExpression(ExpressionType.OrAssign, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.OrAssign, "op_BitwiseOr", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.OrAssign, "op_BitwiseOr", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.OrAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.OrAssign, left, right, method, conversion, liftToNull: true); } /// @@ -2652,7 +2652,7 @@ public static BinaryExpression OrAssign(Expression left, Expression right, Metho /// and the and properties set to the specified values. public static BinaryExpression ExclusiveOr(Expression left, Expression right) { - return ExclusiveOr(left, right, null); + return ExclusiveOr(left, right, method: null); } /// @@ -2674,9 +2674,9 @@ public static BinaryExpression ExclusiveOr(Expression left, Expression right, Me { return new SimpleBinaryExpression(ExpressionType.ExclusiveOr, left, right, left.Type); } - return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.ExclusiveOr, "op_ExclusiveOr", left, right, true); + return GetUserDefinedBinaryOperatorOrThrow(ExpressionType.ExclusiveOr, "op_ExclusiveOr", left, right, liftToNull: true); } - return GetMethodBasedBinaryOperator(ExpressionType.ExclusiveOr, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.ExclusiveOr, left, right, method, liftToNull: true); } /// @@ -2688,7 +2688,7 @@ public static BinaryExpression ExclusiveOr(Expression left, Expression right, Me /// and the and properties set to the specified values. public static BinaryExpression ExclusiveOrAssign(Expression left, Expression right) { - return ExclusiveOrAssign(left, right, null, null); + return ExclusiveOrAssign(left, right, method: null, conversion: null); } /// @@ -2702,7 +2702,7 @@ public static BinaryExpression ExclusiveOrAssign(Expression left, Expression rig /// public static BinaryExpression ExclusiveOrAssign(Expression left, Expression right, MethodInfo method) { - return ExclusiveOrAssign(left, right, method, null); + return ExclusiveOrAssign(left, right, method, conversion: null); } /// @@ -2732,9 +2732,9 @@ public static BinaryExpression ExclusiveOrAssign(Expression left, Expression rig } return new SimpleBinaryExpression(ExpressionType.ExclusiveOrAssign, left, right, left.Type); } - return GetUserDefinedAssignOperatorOrThrow(ExpressionType.ExclusiveOrAssign, "op_ExclusiveOr", left, right, conversion, true); + return GetUserDefinedAssignOperatorOrThrow(ExpressionType.ExclusiveOrAssign, "op_ExclusiveOr", left, right, conversion, liftToNull: true); } - return GetMethodBasedAssignOperator(ExpressionType.ExclusiveOrAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.ExclusiveOrAssign, left, right, method, conversion, liftToNull: true); } /// @@ -2746,7 +2746,7 @@ public static BinaryExpression ExclusiveOrAssign(Expression left, Expression rig /// and the and properties set to the specified values. public static BinaryExpression Power(Expression left, Expression right) { - return Power(left, right, null); + return Power(left, right, method: null); } /// @@ -2770,7 +2770,7 @@ public static BinaryExpression Power(Expression left, Expression right, MethodIn throw Error.BinaryOperatorNotDefined(ExpressionType.Power, left.Type, right.Type); } } - return GetMethodBasedBinaryOperator(ExpressionType.Power, left, right, method, true); + return GetMethodBasedBinaryOperator(ExpressionType.Power, left, right, method, liftToNull: true); } /// @@ -2782,7 +2782,7 @@ public static BinaryExpression Power(Expression left, Expression right, MethodIn /// and the and properties set to the specified values. public static BinaryExpression PowerAssign(Expression left, Expression right) { - return PowerAssign(left, right, null, null); + return PowerAssign(left, right, method: null, conversion: null); } /// @@ -2796,7 +2796,7 @@ public static BinaryExpression PowerAssign(Expression left, Expression right) /// public static BinaryExpression PowerAssign(Expression left, Expression right, MethodInfo method) { - return PowerAssign(left, right, method, null); + return PowerAssign(left, right, method, conversion: null); } /// @@ -2823,7 +2823,7 @@ public static BinaryExpression PowerAssign(Expression left, Expression right, Me throw Error.BinaryOperatorNotDefined(ExpressionType.PowerAssign, left.Type, right.Type); } } - return GetMethodBasedAssignOperator(ExpressionType.PowerAssign, left, right, method, conversion, true); + return GetMethodBasedAssignOperator(ExpressionType.PowerAssign, left, right, method, conversion, liftToNull: true); } #endregion diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/CatchBlock.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/CatchBlock.cs index 0aa37c87c64e..1ebf20ebfe15 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/CatchBlock.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/CatchBlock.cs @@ -82,7 +82,7 @@ public partial class Expression /// The created . public static CatchBlock Catch(Type type, Expression body) { - return MakeCatchBlock(type, null, body, null); + return MakeCatchBlock(type, null, body, filter: null); } /// @@ -94,7 +94,7 @@ public static CatchBlock Catch(Type type, Expression body) public static CatchBlock Catch(ParameterExpression variable, Expression body) { ContractUtils.RequiresNotNull(variable, nameof(variable)); - return MakeCatchBlock(variable.Type, variable, body, null); + return MakeCatchBlock(variable.Type, variable, body, filter: null); } /// diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/HoistedLocals.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/HoistedLocals.cs index d9774258c7bb..aadb7ce843d4 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/HoistedLocals.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/HoistedLocals.cs @@ -72,7 +72,7 @@ internal HoistedLocals(HoistedLocals parent, ReadOnlyCollection(indexes); diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Address.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Address.cs index fbc4d355df36..b5144fb42951 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Address.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Address.cs @@ -84,7 +84,7 @@ private void AddressOf(BinaryExpression node, Type type) Type indexType = TypeUtils.GetNonNullableType(rightType); if (indexType != typeof(int)) { - _ilg.EmitConvertToType(indexType, typeof(int), true); + _ilg.EmitConvertToType(indexType, typeof(int), isChecked: true); } _ilg.Emit(OpCodes.Ldelema, node.Type); } @@ -290,7 +290,7 @@ private WriteBack AddressOfWriteBackCore(MemberExpression node) PropertyInfo pi = (PropertyInfo)node.Member; // emit the get - EmitCall(instanceType, pi.GetGetMethod(true)); + EmitCall(instanceType, pi.GetGetMethod(nonPublic: true)); // emit the address of the value LocalBuilder valueLocal = GetLocal(node.Type); @@ -308,7 +308,7 @@ private WriteBack AddressOfWriteBackCore(MemberExpression node) } @this._ilg.Emit(OpCodes.Ldloc, valueLocal); @this.FreeLocal(valueLocal); - @this.EmitCall(instanceLocal?.LocalType, pi.GetSetMethod(true)); + @this.EmitCall(instanceLocal?.LocalType, pi.GetSetMethod(nonPublic: true)); }; } diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs index 66b961c535d4..4ff3c1aaf030 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Binary.cs @@ -94,8 +94,8 @@ private void EmitBinaryMethod(BinaryExpression b, CompilationFlags flags) { if (b.IsLifted) { - ParameterExpression p1 = Expression.Variable(TypeUtils.GetNonNullableType(b.Left.Type), null); - ParameterExpression p2 = Expression.Variable(TypeUtils.GetNonNullableType(b.Right.Type), null); + ParameterExpression p1 = Expression.Variable(TypeUtils.GetNonNullableType(b.Left.Type), name: null); + ParameterExpression p2 = Expression.Variable(TypeUtils.GetNonNullableType(b.Right.Type), name: null); MethodCallExpression mc = Expression.Call(null, b.Method, p1, p2); Type resultType = null; if (b.IsLiftedToNull) @@ -549,7 +549,7 @@ private void EmitLiftedRelational(ExpressionType op, Type leftType, Type rightTy TypeUtils.GetNonNullableType(leftType), TypeUtils.GetNonNullableType(rightType), TypeUtils.GetNonNullableType(resultType), - false + liftedToNull: false ); if (!liftedToNull) @@ -559,7 +559,7 @@ private void EmitLiftedRelational(ExpressionType op, Type leftType, Type rightTy if (!TypeUtils.AreEquivalent(resultType, TypeUtils.GetNonNullableType(resultType))) { - _ilg.EmitConvertToType(TypeUtils.GetNonNullableType(resultType), resultType, true); + _ilg.EmitConvertToType(TypeUtils.GetNonNullableType(resultType), resultType, isChecked: true); } if (liftedToNull) @@ -632,7 +632,7 @@ private void EmitLiftedBinaryArithmetic(ExpressionType op, Type leftType, Type r FreeLocal(locLeft); FreeLocal(locRight); - EmitBinaryOperator(op, TypeUtils.GetNonNullableType(leftType), TypeUtils.GetNonNullableType(rightType), TypeUtils.GetNonNullableType(resultType), false); + EmitBinaryOperator(op, TypeUtils.GetNonNullableType(leftType), TypeUtils.GetNonNullableType(rightType), TypeUtils.GetNonNullableType(resultType), liftedToNull: false); // construct result type ConstructorInfo ci = resultType.GetConstructor(new Type[] { TypeUtils.GetNonNullableType(resultType) }); diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs index c78756d2b713..d19a5a5ccb1f 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Expressions.cs @@ -291,7 +291,7 @@ private void EmitGetIndexCall(IndexExpression node, Type objectType) if (node.Indexer != null) { // For indexed properties, just call the getter - MethodInfo method = node.Indexer.GetGetMethod(true); + MethodInfo method = node.Indexer.GetGetMethod(nonPublic: true); EmitCall(objectType, method); } else @@ -319,7 +319,7 @@ private void EmitSetIndexCall(IndexExpression node, Type objectType) if (node.Indexer != null) { // For indexed properties, just call the setter - MethodInfo method = node.Indexer.GetSetMethod(true); + MethodInfo method = node.Indexer.GetSetMethod(nonPublic: true); EmitCall(objectType, method); } else @@ -800,7 +800,7 @@ private void EmitMemberAssignment(BinaryExpression node, CompilationFlags flags) // MemberExpression.Member can only be a FieldInfo or a PropertyInfo Debug.Assert(member is PropertyInfo); var prop = (PropertyInfo)member; - EmitCall(objectType, prop.GetSetMethod(true)); + EmitCall(objectType, prop.GetSetMethod(nonPublic: true)); } if (emitAs != CompilationFlags.EmitAsVoidType) @@ -846,7 +846,7 @@ private void EmitMemberGet(MemberInfo member, Type objectType) // MemberExpression.Member or MemberBinding.Member can only be a FieldInfo or a PropertyInfo Debug.Assert(member is PropertyInfo); var prop = (PropertyInfo)member; - EmitCall(objectType, prop.GetGetMethod(true)); + EmitCall(objectType, prop.GetGetMethod(nonPublic: true)); } } @@ -858,7 +858,7 @@ private static bool TryGetRawConstantValue(FieldInfo fi, out object value) try { - value = fi.GetValue(null); + value = fi.GetValue(obj: null); return true; } catch @@ -908,7 +908,7 @@ private void EmitNewArrayExpression(Expression expr) { Expression x = expressions[i]; EmitExpression(x); - _ilg.EmitConvertToType(x.Type, typeof(int), true); + _ilg.EmitConvertToType(x.Type, typeof(int), isChecked: true); } _ilg.EmitArray(node.Type); } @@ -968,7 +968,7 @@ private void EmitMemberAssignment(MemberAssignment binding, Type objectType) PropertyInfo pi = binding.Member as PropertyInfo; if (pi != null) { - EmitCall(objectType, pi.GetSetMethod(true)); + EmitCall(objectType, pi.GetSetMethod(nonPublic: true)); } else { diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Logical.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Logical.cs index bd6b8148d8ff..66c30f302e18 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Logical.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Logical.cs @@ -151,7 +151,7 @@ private void EmitNullableCoalesce(BinaryExpression b) { _ilg.Emit(OpCodes.Ldloca, loc); _ilg.EmitGetValueOrDefault(b.Left.Type); - _ilg.EmitConvertToType(nnLeftType, b.Type, true); + _ilg.EmitConvertToType(nnLeftType, b.Type, isChecked: true); } else { @@ -165,7 +165,7 @@ private void EmitNullableCoalesce(BinaryExpression b) EmitExpression(b.Right); if (!TypeUtils.AreEquivalent(b.Right.Type, b.Type)) { - _ilg.EmitConvertToType(b.Right.Type, b.Type, true); + _ilg.EmitConvertToType(b.Right.Type, b.Type, isChecked: true); } _ilg.MarkLabel(labEnd); } diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Statements.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Statements.cs index 105c45bdc1c9..f9a4afb43368 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Statements.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Statements.cs @@ -937,7 +937,7 @@ private void EmitCatchStart(CatchBlock cb) // begin the catch, clear the exception, we've // already saved it _ilg.MarkLabel(endFilter); - _ilg.BeginCatchBlock(null); + _ilg.BeginCatchBlock(exceptionType: null); _ilg.Emit(OpCodes.Pop); } diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Unary.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Unary.cs index 52945520293a..df769bfc8853 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Unary.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Compiler/LambdaCompiler.Unary.cs @@ -78,10 +78,10 @@ private void EmitUnary(UnaryExpression node, CompilationFlags flags) LocalBuilder loc = GetLocal(node.Operand.Type); _ilg.Emit(OpCodes.Stloc, loc); _ilg.EmitInt(0); - _ilg.EmitConvertToType(typeof(int), node.Operand.Type, false); + _ilg.EmitConvertToType(typeof(int), node.Operand.Type, isChecked: false); _ilg.Emit(OpCodes.Ldloc, loc); FreeLocal(loc); - EmitBinaryOperator(ExpressionType.SubtractChecked, node.Operand.Type, node.Operand.Type, node.Type, false); + EmitBinaryOperator(ExpressionType.SubtractChecked, node.Operand.Type, node.Operand.Type, node.Type, liftedToNull: false); } else { @@ -366,12 +366,12 @@ private void EmitUnaryMethod(UnaryExpression node, CompilationFlags flags) { if (node.IsLifted) { - ParameterExpression v = Expression.Variable(TypeUtils.GetNonNullableType(node.Operand.Type), null); + ParameterExpression v = Expression.Variable(TypeUtils.GetNonNullableType(node.Operand.Type), name: null); MethodCallExpression mc = Expression.Call(node.Method, v); Type resultType = TypeUtils.GetNullableType(mc.Type); EmitLift(node.NodeType, resultType, mc, new ParameterExpression[] { v }, new Expression[] { node.Operand }); - _ilg.EmitConvertToType(resultType, node.Type, false); + _ilg.EmitConvertToType(resultType, node.Type, isChecked: false); } else { diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Expression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Expression.cs index e278c49aa155..6e158f942a27 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Expression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Expression.cs @@ -57,7 +57,7 @@ protected Expression(ExpressionType nodeType, Type type) Interlocked.CompareExchange( ref s_legacyCtorSupportTable, new ConditionalWeakTable(), - null +comparand: null ); } diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/IndexExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/IndexExpression.cs index a056b695c904..59a797078479 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/IndexExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/IndexExpression.cs @@ -285,7 +285,7 @@ private static bool IsCompatible(PropertyInfo pi, Expression[] args) { MethodInfo mi; - mi = pi.GetGetMethod(true); + mi = pi.GetGetMethod(nonPublic: true); ParameterInfo[] parms; if (mi != null) { @@ -293,7 +293,7 @@ private static bool IsCompatible(PropertyInfo pi, Expression[] args) } else { - mi = pi.GetSetMethod(true); + mi = pi.GetSetMethod(nonPublic: true); //The setter has an additional parameter for the value to set, //need to remove the last type to match the arguments. parms = mi.GetParametersCached().RemoveLast(); @@ -366,14 +366,14 @@ private static void ValidateIndexedProperty(Expression instance, PropertyInfo pr if (property.PropertyType == typeof(void)) throw Error.PropertyTypeCannotBeVoid(nameof(property)); ParameterInfo[] getParameters = null; - MethodInfo getter = property.GetGetMethod(true); + MethodInfo getter = property.GetGetMethod(nonPublic: true); if (getter != null) { getParameters = getter.GetParametersCached(); ValidateAccessor(instance, getter, getParameters, ref argList, nameof(property)); } - MethodInfo setter = property.GetSetMethod(true); + MethodInfo setter = property.GetSetMethod(nonPublic: true); if (setter != null) { ParameterInfo[] setParameters = setter.GetParametersCached(); diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/FieldOperations.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/FieldOperations.cs index eb4dc9342afa..fba480cf259e 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/FieldOperations.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/FieldOperations.cs @@ -22,7 +22,7 @@ public LoadStaticFieldInstruction(FieldInfo field) public override int Run(InterpretedFrame frame) { - frame.Push(_field.GetValue(null)); + frame.Push(_field.GetValue(obj: null)); return +1; } } diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/InstructionList.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/InstructionList.cs index b6f0c71c0120..5b6d2c1510c4 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/InstructionList.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/InstructionList.cs @@ -321,7 +321,7 @@ public InstructionArray ToArray() public void EmitLoad(object value) { - EmitLoad(value, null); + EmitLoad(value, type: null); } public void EmitLoad(bool value) diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightCompiler.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightCompiler.cs index 4b49b3638355..e0e90ef6067d 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightCompiler.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightCompiler.cs @@ -369,7 +369,7 @@ private void CompileDefaultExpression(Type type) } else { - _instructions.EmitLoad(null); + _instructions.EmitLoad(value: null); } } } @@ -591,7 +591,7 @@ private void EmitIndexGet(IndexExpression index) { if (index.Indexer != null) { - _instructions.EmitCall(index.Indexer.GetGetMethod(true)); + _instructions.EmitCall(index.Indexer.GetGetMethod(nonPublic: true)); } else if (index.ArgumentCount != 1) { @@ -630,7 +630,7 @@ private void CompileIndexAssignment(BinaryExpression node, bool asVoid) if (index.Indexer != null) { - _instructions.EmitCall(index.Indexer.GetSetMethod(true)); + _instructions.EmitCall(index.Indexer.GetSetMethod(nonPublic: true)); } else if (index.ArgumentCount != 1) { @@ -657,7 +657,7 @@ private void CompileMemberAssignment(BinaryExpression node, bool asVoid) EmitThisForMethodCall(expr); } - CompileMemberAssignment(asVoid, member.Member, node.Right, false); + CompileMemberAssignment(asVoid, member.Member, node.Right, forBinding: false); } private void CompileMemberAssignment(bool asVoid, MemberInfo refMember, Expression value, bool forBinding) @@ -665,7 +665,7 @@ private void CompileMemberAssignment(bool asVoid, MemberInfo refMember, Expressi var pi = refMember as PropertyInfo; if (pi != null) { - MethodInfo method = pi.GetSetMethod(true); + MethodInfo method = pi.GetSetMethod(nonPublic: true); if (forBinding && method.IsStatic) { throw Error.InvalidProgram(); @@ -813,7 +813,7 @@ private void CompileBinaryExpression(Expression expr) { _instructions.EmitNotEqual(typeof(object)); } - _instructions.EmitBranch(end, false, true); + _instructions.EmitBranch(end, hasResult: false, hasValue: true); _instructions.MarkLabel(testRight); @@ -833,7 +833,7 @@ private void CompileBinaryExpression(Expression expr) // right null, left not, true _instructions.EmitLoad(ScriptingRuntimeHelpers.True, typeof(bool)); } - _instructions.EmitBranch(end, false, true); + _instructions.EmitBranch(end, hasResult: false, hasValue: true); // both are not null _instructions.MarkLabel(callMethod); @@ -863,7 +863,7 @@ private void CompileBinaryExpression(Expression expr) _instructions.EmitLoadLocal(leftTemp.Index); _instructions.EmitLoadLocal(rightTemp.Index); _instructions.EmitCall(node.Method); - _instructions.EmitBranch(end, false, true); + _instructions.EmitBranch(end, hasResult: false, hasValue: true); _instructions.MarkLabel(loadDefault); switch (node.NodeType) @@ -1008,12 +1008,12 @@ private void CompileArithmetic(ExpressionType nodeType, Expression left, Express Compile(right); switch (nodeType) { - case ExpressionType.Add: _instructions.EmitAdd(left.Type, false); break; - case ExpressionType.AddChecked: _instructions.EmitAdd(left.Type, true); break; - case ExpressionType.Subtract: _instructions.EmitSub(left.Type, false); break; - case ExpressionType.SubtractChecked: _instructions.EmitSub(left.Type, true); break; - case ExpressionType.Multiply: _instructions.EmitMul(left.Type, false); break; - case ExpressionType.MultiplyChecked: _instructions.EmitMul(left.Type, true); break; + case ExpressionType.Add: _instructions.EmitAdd(left.Type, @checked: false); break; + case ExpressionType.AddChecked: _instructions.EmitAdd(left.Type, @checked: true); break; + case ExpressionType.Subtract: _instructions.EmitSub(left.Type, @checked: false); break; + case ExpressionType.SubtractChecked: _instructions.EmitSub(left.Type, @checked: true); break; + case ExpressionType.Multiply: _instructions.EmitMul(left.Type, @checked: false); break; + case ExpressionType.MultiplyChecked: _instructions.EmitMul(left.Type, @checked: true); break; case ExpressionType.Divide: _instructions.EmitDiv(left.Type); break; case ExpressionType.Modulo: _instructions.EmitModulo(left.Type); break; default: throw ContractUtils.Unreachable; @@ -1050,7 +1050,7 @@ private void CompileConvertUnaryExpression(Expression expr) _instructions.EmitCall(node.Method); - _instructions.EmitBranch(end, false, true); + _instructions.EmitBranch(end, hasResult: false, hasValue: true); _instructions.MarkLabel(loadDefault); _instructions.EmitLoad(null, typeof(object)); @@ -1277,12 +1277,12 @@ private void EmitUnaryBoolCheck(UnaryExpression node) private void CompileAndAlsoBinaryExpression(Expression expr) { - CompileLogicalBinaryExpression((BinaryExpression)expr, true); + CompileLogicalBinaryExpression((BinaryExpression)expr, andAlso: true); } private void CompileOrElseBinaryExpression(Expression expr) { - CompileLogicalBinaryExpression((BinaryExpression)expr, false); + CompileLogicalBinaryExpression((BinaryExpression)expr, andAlso: false); } private void CompileLogicalBinaryExpression(BinaryExpression b, bool andAlso) @@ -1419,7 +1419,7 @@ private void CompileUnliftedLogicalBinaryExpression(BinaryExpression expr, bool _instructions.EmitBranchTrue(elseLabel); } Compile(expr.Right); - _instructions.EmitBranch(endLabel, false, true); + _instructions.EmitBranch(endLabel, hasResult: false, hasValue: true); _instructions.MarkLabel(elseLabel); _instructions.EmitLoad(!andAlso); _instructions.MarkLabel(endLabel); @@ -1474,7 +1474,7 @@ private void CompileLoopExpression(Expression expr) CompileAsVoid(node.Body); // emit loop branch: - _instructions.EmitBranch(continueLabel.GetLabel(this), node.Type != typeof(void), false); + _instructions.EmitBranch(continueLabel.GetLabel(this), node.Type != typeof(void), hasValue: false); _instructions.MarkLabel(breakLabel.GetLabel(this)); @@ -1586,7 +1586,7 @@ private void CompileSwitchExpression(Expression expr) private void CompileIntSwitchExpression(SwitchExpression node) { - LabelInfo end = DefineLabel(null); + LabelInfo end = DefineLabel(node: null); bool hasValue = node.Type != typeof(void); Compile(node.SwitchValue); @@ -1631,7 +1631,7 @@ private void CompileIntSwitchExpression(SwitchExpression node) private void CompileStringSwitchExpression(SwitchExpression node) { - LabelInfo end = DefineLabel(null); + LabelInfo end = DefineLabel(node: null); bool hasValue = node.Type != typeof(void); Compile(node.SwitchValue); @@ -2003,7 +2003,7 @@ private void CompileTryExpression(Expression expr) int filterLabel = _instructions.MarkRuntimeLabel(); int filterStart = _instructions.Count; - CompileSetVariable(parameter, true); + CompileSetVariable(parameter, isVoid: true); Compile(handler.Filter); filter = new ExceptionFilter(filterLabel, filterStart, _instructions.Count); @@ -2030,7 +2030,7 @@ private void CompileTryExpression(Expression expr) int handlerLabel = _instructions.MarkRuntimeLabel(); int handlerStart = _instructions.Count; - CompileSetVariable(parameter, true); + CompileSetVariable(parameter, isVoid: true); Compile(handler.Body, !hasValue); _exceptionForRethrowStack.Pop(); @@ -2308,7 +2308,7 @@ private ByRefUpdater CompileAddress(Expression node, int index) } Debug.Assert(member.Member is PropertyInfo); var property = (PropertyInfo)member.Member; - _instructions.EmitCall(property.GetGetMethod(true)); + _instructions.EmitCall(property.GetGetMethod(nonPublic: true)); if (property.CanWrite) { return new PropertyByRefUpdater(memberTemp, property, index); @@ -2419,7 +2419,7 @@ private void CompileMemberExpression(Expression expr) { var node = (MemberExpression)expr; - CompileMember(node.Expression, node.Member, false); + CompileMember(node.Expression, node.Member, forBinding: false); } private void CompileMember(Expression from, MemberInfo member, bool forBinding) @@ -2430,7 +2430,7 @@ private void CompileMember(Expression from, MemberInfo member, bool forBinding) if (fi.IsLiteral) { Debug.Assert(!forBinding); - _instructions.EmitLoad(fi.GetValue(null), fi.FieldType); + _instructions.EmitLoad(fi.GetValue(obj: null), fi.FieldType); } else if (fi.IsStatic) { @@ -2441,7 +2441,7 @@ private void CompileMember(Expression from, MemberInfo member, bool forBinding) if (fi.IsInitOnly) { - _instructions.EmitLoad(fi.GetValue(null), fi.FieldType); + _instructions.EmitLoad(fi.GetValue(obj: null), fi.FieldType); } else { @@ -2464,7 +2464,7 @@ private void CompileMember(Expression from, MemberInfo member, bool forBinding) var pi = (PropertyInfo)member; if (pi != null) { - MethodInfo method = pi.GetGetMethod(true); + MethodInfo method = pi.GetGetMethod(nonPublic: true); if (forBinding && method.IsStatic) { throw Error.InvalidProgram(); @@ -2698,13 +2698,13 @@ private void CompileMemberInit(ReadOnlyCollection bindings) true, ((MemberAssignment)binding).Member, ((MemberAssignment)binding).Expression, - true + forBinding: true ); break; case MemberBindingType.ListBinding: var memberList = (MemberListBinding)binding; _instructions.EmitDup(); - CompileMember(null, memberList.Member, true); + CompileMember(null, memberList.Member, forBinding: true); CompileListInit(memberList.Initializers); _instructions.EmitPop(); break; @@ -2717,7 +2717,7 @@ private void CompileMemberInit(ReadOnlyCollection bindings) throw Error.CannotAutoInitializeValueTypeMemberThroughProperty(memberMember.Bindings); } - CompileMember(null, memberMember.Member, true); + CompileMember(null, memberMember.Member, forBinding: true); CompileMemberInit(memberMember.Bindings); _instructions.EmitPop(); break; @@ -2933,15 +2933,15 @@ internal void CompileAsVoid(Expression expr) switch (expr.NodeType) { case ExpressionType.Assign: - CompileAssignBinaryExpression(expr, true); + CompileAssignBinaryExpression(expr, asVoid: true); break; case ExpressionType.Block: - CompileBlockExpression(expr, true); + CompileBlockExpression(expr, asVoid: true); break; case ExpressionType.Throw: - CompileThrowUnaryExpression(expr, true); + CompileThrowUnaryExpression(expr, asVoid: true); break; case ExpressionType.Constant: diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightDelegateCreator.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightDelegateCreator.cs index 6446a817b66e..5e9fc0daa877 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightDelegateCreator.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/Interpreter/LightDelegateCreator.cs @@ -25,7 +25,7 @@ internal LightDelegateCreator(Interpreter interpreter, LambdaExpression lambda) internal Interpreter Interpreter { get; } - public Delegate CreateDelegate() => CreateDelegate(null); + public Delegate CreateDelegate() => CreateDelegate(closure: null); internal Delegate CreateDelegate(IStrongBox[] closure) { diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/LabelExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/LabelExpression.cs index 38cca1d66d64..f0ad786a15d4 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/LabelExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/LabelExpression.cs @@ -79,7 +79,7 @@ public partial class Expression /// A with no default value. public static LabelExpression Label(LabelTarget target) { - return Label(target, null); + return Label(target, defaultValue: null); } /// @@ -90,7 +90,7 @@ public static LabelExpression Label(LabelTarget target) /// A with the given default value. public static LabelExpression Label(LabelTarget target, Expression defaultValue) { - ValidateGoto(target, ref defaultValue, nameof(target), nameof(defaultValue), null); + ValidateGoto(target, ref defaultValue, nameof(target), nameof(defaultValue), type: null); return new LabelExpression(target, defaultValue); } } diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/LabelTarget.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/LabelTarget.cs index fcc7f1ebc6ae..a661626ffe20 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/LabelTarget.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/LabelTarget.cs @@ -48,7 +48,7 @@ public partial class Expression /// The new . public static LabelTarget Label() { - return Label(typeof(void), null); + return Label(typeof(void), name: null); } /// @@ -68,7 +68,7 @@ public static LabelTarget Label(string name) /// The new . public static LabelTarget Label(Type type) { - return Label(type, null); + return Label(type, name: null); } /// diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/ListInitExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/ListInitExpression.cs index 07b0a326052c..ef95e0252add 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/ListInitExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/ListInitExpression.cs @@ -71,7 +71,7 @@ protected internal override Expression Accept(ExpressionVisitor visitor) /// The reduced expression. public override Expression Reduce() { - return MemberInitExpression.ReduceListInit(NewExpression, Initializers, true); + return MemberInitExpression.ReduceListInit(NewExpression, Initializers, keepOnStack: true); } /// diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/LoopExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/LoopExpression.cs index 62a9cea8b091..19b33340790e 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/LoopExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/LoopExpression.cs @@ -83,7 +83,7 @@ public partial class Expression /// The created . public static LoopExpression Loop(Expression body) { - return Loop(body, null); + return Loop(body, @break: null); } /// @@ -94,7 +94,7 @@ public static LoopExpression Loop(Expression body) /// The created . public static LoopExpression Loop(Expression body, LabelTarget @break) { - return Loop(body, @break, null); + return Loop(body, @break, @continue: null); } /// diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberExpression.cs index 79940d822e5f..97a2dfb69153 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberExpression.cs @@ -259,11 +259,11 @@ public static MemberExpression Property(Expression expression, PropertyInfo prop { ContractUtils.RequiresNotNull(property, nameof(property)); - MethodInfo mi = property.GetGetMethod(true); + MethodInfo mi = property.GetGetMethod(nonPublic: true); if (mi == null) { - mi = property.GetSetMethod(true); + mi = property.GetSetMethod(nonPublic: true); if (mi == null) { @@ -317,11 +317,11 @@ private static PropertyInfo GetProperty(MethodInfo mi, string paramName, int ind PropertyInfo[] props = type.GetProperties(flags); foreach (PropertyInfo pi in props) { - if (pi.CanRead && CheckMethod(mi, pi.GetGetMethod(true))) + if (pi.CanRead && CheckMethod(mi, pi.GetGetMethod(nonPublic: true))) { return pi; } - if (pi.CanWrite && CheckMethod(mi, pi.GetSetMethod(true))) + if (pi.CanWrite && CheckMethod(mi, pi.GetSetMethod(nonPublic: true))) { return pi; } diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberInitExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberInitExpression.cs index 63ed1b6ce8aa..80827f4f6561 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberInitExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/MemberInitExpression.cs @@ -65,12 +65,12 @@ protected internal override Expression Accept(ExpressionVisitor visitor) /// The reduced expression. public override Expression Reduce() { - return ReduceMemberInit(NewExpression, Bindings, true); + return ReduceMemberInit(NewExpression, Bindings, keepOnStack: true); } internal static Expression ReduceMemberInit(Expression objExpression, ReadOnlyCollection bindings, bool keepOnStack) { - ParameterExpression objVar = Expression.Variable(objExpression.Type, null); + ParameterExpression objVar = Expression.Variable(objExpression.Type, name: null); int count = bindings.Count; var block = new Expression[count + 2]; block[0] = Expression.Assign(objVar, objExpression); @@ -84,7 +84,7 @@ internal static Expression ReduceMemberInit(Expression objExpression, ReadOnlyCo internal static Expression ReduceListInit(Expression listExpression, ReadOnlyCollection initializers, bool keepOnStack) { - ParameterExpression listVar = Expression.Variable(listExpression.Type, null); + ParameterExpression listVar = Expression.Variable(listExpression.Type, name: null); int count = initializers.Count; var block = new Expression[count + 2]; block[0] = Expression.Assign(listVar, listExpression); @@ -105,9 +105,9 @@ internal static Expression ReduceMemberBinding(ParameterExpression objVar, Membe case MemberBindingType.Assignment: return Expression.Assign(member, ((MemberAssignment)binding).Expression); case MemberBindingType.ListBinding: - return ReduceListInit(member, ((MemberListBinding)binding).Initializers, false); + return ReduceListInit(member, ((MemberListBinding)binding).Initializers, keepOnStack: false); case MemberBindingType.MemberBinding: - return ReduceMemberInit(member, ((MemberMemberBinding)binding).Bindings, false); + return ReduceMemberInit(member, ((MemberMemberBinding)binding).Bindings, keepOnStack: false); default: throw ContractUtils.Unreachable; } } diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/ParameterExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/ParameterExpression.cs index 3556e226e02f..a662ed387e61 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/ParameterExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/ParameterExpression.cs @@ -156,7 +156,7 @@ public partial class Expression /// A node with the specified name and type. public static ParameterExpression Parameter(Type type) { - return Parameter(type, null); + return Parameter(type, name: null); } /// @@ -166,7 +166,7 @@ public static ParameterExpression Parameter(Type type) /// A node with the specified name and type. public static ParameterExpression Variable(Type type) { - return Variable(type, null); + return Variable(type, name: null); } /// @@ -215,7 +215,7 @@ public static ParameterExpression Variable(Type type, string name) throw Error.TypeMustNotBePointer(nameof(type)); } - return ParameterExpression.Make(type, name, false); + return ParameterExpression.Make(type, name, isByRef: false); } } } diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/TryExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/TryExpression.cs index b5a0b89965b6..62dc4d73cc0c 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/TryExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/TryExpression.cs @@ -101,7 +101,7 @@ public partial class Expression /// The created . public static TryExpression TryFault(Expression body, Expression fault) { - return MakeTry(null, body, null, fault, null); + return MakeTry(null, body, null, fault, handlers: null); } /// @@ -112,7 +112,7 @@ public static TryExpression TryFault(Expression body, Expression fault) /// The created . public static TryExpression TryFinally(Expression body, Expression @finally) { - return MakeTry(null, body, @finally, null, null); + return MakeTry(null, body, @finally, fault: null, handlers: null); } /// diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/TypeBinaryExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/TypeBinaryExpression.cs index f46d3aa6be86..f589b098004e 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/TypeBinaryExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/TypeBinaryExpression.cs @@ -60,7 +60,7 @@ internal Expression ReduceTypeEqual() // either matches or is its type argument (T to its T?). if (cType.GetNonNullableType() != TypeOperand.GetNonNullableType()) { - return Expression.Block(Expression, Expression.Constant(false)); + return Expression.Block(Expression, Expression.Constant(value: false)); } else { @@ -120,7 +120,7 @@ private Expression ByValParameterTypeEqual(ParameterExpression value) // (don't invoke a user defined operator), and reference equality // on types for performance (so the JIT can optimize the IL). return Expression.AndAlso( - Expression.ReferenceNotEqual(value, Expression.Constant(null)), + Expression.ReferenceNotEqual(value, Expression.Constant(value: null)), Expression.ReferenceEqual( getType, Expression.Constant(TypeOperand.GetNonNullableType(), typeof(Type)) @@ -134,7 +134,7 @@ private Expression ReduceConstantTypeEqual() //TypeEqual(null, T) always returns false. if (ce.Value == null) { - return Expression.Constant(false); + return Expression.Constant(value: false); } else { diff --git a/src/System.Linq.Expressions/src/System/Linq/Expressions/UnaryExpression.cs b/src/System.Linq.Expressions/src/System/Linq/Expressions/UnaryExpression.cs index 8b35fa6a3e50..c6abb342eb7a 100644 --- a/src/System.Linq.Expressions/src/System/Linq/Expressions/UnaryExpression.cs +++ b/src/System.Linq.Expressions/src/System/Linq/Expressions/UnaryExpression.cs @@ -168,7 +168,7 @@ private Expression ReduceVariable() // temp = var // var = op(var) // temp - ParameterExpression temp = Parameter(Operand.Type, null); + ParameterExpression temp = Parameter(Operand.Type, name: null); return Block( new[] { temp }, Assign(temp, Operand), @@ -187,7 +187,7 @@ private Expression ReduceMember() } else { - ParameterExpression temp1 = Parameter(member.Expression.Type, null); + ParameterExpression temp1 = Parameter(member.Expression.Type, name: null); BinaryExpression initTemp1 = Assign(temp1, member.Expression); member = MakeMemberAccess(temp1, member.Member); @@ -210,7 +210,7 @@ private Expression ReduceMember() // temp2 = temp1.member // temp1.member = op(temp2) // temp2 - ParameterExpression temp2 = Parameter(member.Type, null); + ParameterExpression temp2 = Parameter(member.Type, name: null); return Block( new[] { temp1, temp2 }, initTemp1, @@ -243,20 +243,20 @@ private Expression ReduceIndex() var args = new ParameterExpression[count]; int i = 0; - temps[i] = Parameter(index.Object.Type, null); + temps[i] = Parameter(index.Object.Type, name: null); block[i] = Assign(temps[i], index.Object); i++; while (i <= count) { Expression arg = index.GetArgument(i - 1); - args[i - 1] = temps[i] = Parameter(arg.Type, null); + args[i - 1] = temps[i] = Parameter(arg.Type, name: null); block[i] = Assign(temps[i], arg); i++; } index = MakeIndex(temps[0], index.Indexer, new TrueReadOnlyCollection(args)); if (!prefix) { - ParameterExpression lastTemp = temps[i] = Parameter(index.Type, null); + ParameterExpression lastTemp = temps[i] = Parameter(index.Type, name: null); block[i] = Assign(temps[i], index); i++; Debug.Assert(i == temps.Length); @@ -302,7 +302,7 @@ public partial class Expression /// Thrown when is null. public static UnaryExpression MakeUnary(ExpressionType unaryType, Expression operand, Type type) { - return MakeUnary(unaryType, operand, type, null); + return MakeUnary(unaryType, operand, type, method: null); } /// @@ -434,7 +434,7 @@ private static UnaryExpression GetUserDefinedCoercionOrThrow(ExpressionType coer private static UnaryExpression GetUserDefinedCoercion(ExpressionType coercionType, Expression expression, Type convertToType) { - MethodInfo method = TypeUtils.GetUserDefinedCoercionMethod(expression.Type, convertToType, false); + MethodInfo method = TypeUtils.GetUserDefinedCoercionMethod(expression.Type, convertToType, implicitOnly: false); if (method != null) { return new UnaryExpression(coercionType, expression, convertToType, method); @@ -477,7 +477,7 @@ private static UnaryExpression GetMethodBasedCoercionOperator(ExpressionType una /// Thrown when the unary minus operator is not defined for .Type. public static UnaryExpression Negate(Expression expression) { - return Negate(expression, null); + return Negate(expression, method: null); } /// @@ -512,7 +512,7 @@ public static UnaryExpression Negate(Expression expression, MethodInfo method) /// Thrown when the unary minus operator is not defined for .Type. public static UnaryExpression UnaryPlus(Expression expression) { - return UnaryPlus(expression, null); + return UnaryPlus(expression, method: null); } /// @@ -545,7 +545,7 @@ public static UnaryExpression UnaryPlus(Expression expression, MethodInfo method /// Thrown when the unary minus operator is not defined for .Type. public static UnaryExpression NegateChecked(Expression expression) { - return NegateChecked(expression, null); + return NegateChecked(expression, method: null); } /// Creates a that represents an arithmetic negation operation that has overflow checking. The implementing method can be specified. @@ -580,7 +580,7 @@ public static UnaryExpression NegateChecked(Expression expression, MethodInfo me /// The unary not operator is not defined for .Type. public static UnaryExpression Not(Expression expression) { - return Not(expression, null); + return Not(expression, method: null); } /// Creates a that represents a bitwise complement operation. The implementing method can be specified. @@ -619,7 +619,7 @@ public static UnaryExpression Not(Expression expression, MethodInfo method) /// An instance of . public static UnaryExpression IsFalse(Expression expression) { - return IsFalse(expression, null); + return IsFalse(expression, method: null); } /// @@ -649,7 +649,7 @@ public static UnaryExpression IsFalse(Expression expression, MethodInfo method) /// An instance of . public static UnaryExpression IsTrue(Expression expression) { - return IsTrue(expression, null); + return IsTrue(expression, method: null); } /// @@ -679,7 +679,7 @@ public static UnaryExpression IsTrue(Expression expression, MethodInfo method) /// An instance of . public static UnaryExpression OnesComplement(Expression expression) { - return OnesComplement(expression, null); + return OnesComplement(expression, method: null); } /// @@ -749,7 +749,7 @@ public static UnaryExpression Unbox(Expression expression, Type type) /// No conversion operator is defined between .Type and . public static UnaryExpression Convert(Expression expression, Type type) { - return Convert(expression, type, null); + return Convert(expression, type, method: null); } /// Creates a that represents a conversion operation for which the implementing method is specified. @@ -799,7 +799,7 @@ public static UnaryExpression Convert(Expression expression, Type type, MethodIn /// No conversion operator is defined between .Type and . public static UnaryExpression ConvertChecked(Expression expression, Type type) { - return ConvertChecked(expression, type, null); + return ConvertChecked(expression, type, method: null); } /// Creates a that represents a conversion operation that throws an exception if the target type is overflowed and for which the implementing method is specified. @@ -883,7 +883,7 @@ public static UnaryExpression Quote(Expression expression) /// A that represents a rethrowing of an exception. public static UnaryExpression Rethrow() { - return Throw(null); + return Throw(value: null); } /// @@ -932,7 +932,7 @@ public static UnaryExpression Throw(Expression value, Type type) /// A that represents the incremented expression. public static UnaryExpression Increment(Expression expression) { - return Increment(expression, null); + return Increment(expression, method: null); } /// @@ -962,7 +962,7 @@ public static UnaryExpression Increment(Expression expression, MethodInfo method /// A that represents the decremented expression. public static UnaryExpression Decrement(Expression expression) { - return Decrement(expression, null); + return Decrement(expression, method: null); } /// @@ -993,7 +993,7 @@ public static UnaryExpression Decrement(Expression expression, MethodInfo method /// A that represents the resultant expression. public static UnaryExpression PreIncrementAssign(Expression expression) { - return MakeOpAssignUnary(ExpressionType.PreIncrementAssign, expression, null); + return MakeOpAssignUnary(ExpressionType.PreIncrementAssign, expression, method: null); } /// @@ -1016,7 +1016,7 @@ public static UnaryExpression PreIncrementAssign(Expression expression, MethodIn /// A that represents the resultant expression. public static UnaryExpression PreDecrementAssign(Expression expression) { - return MakeOpAssignUnary(ExpressionType.PreDecrementAssign, expression, null); + return MakeOpAssignUnary(ExpressionType.PreDecrementAssign, expression, method: null); } /// @@ -1039,7 +1039,7 @@ public static UnaryExpression PreDecrementAssign(Expression expression, MethodIn /// A that represents the resultant expression. public static UnaryExpression PostIncrementAssign(Expression expression) { - return MakeOpAssignUnary(ExpressionType.PostIncrementAssign, expression, null); + return MakeOpAssignUnary(ExpressionType.PostIncrementAssign, expression, method: null); } /// @@ -1062,7 +1062,7 @@ public static UnaryExpression PostIncrementAssign(Expression expression, MethodI /// A that represents the resultant expression. public static UnaryExpression PostDecrementAssign(Expression expression) { - return MakeOpAssignUnary(ExpressionType.PostDecrementAssign, expression, null); + return MakeOpAssignUnary(ExpressionType.PostDecrementAssign, expression, method: null); } /// diff --git a/src/System.Linq.Expressions/src/System/Runtime/CompilerServices/ReadOnlyCollectionBuilder.cs b/src/System.Linq.Expressions/src/System/Runtime/CompilerServices/ReadOnlyCollectionBuilder.cs index 3e2a4225d021..eac6b38ed77a 100644 --- a/src/System.Linq.Expressions/src/System/Runtime/CompilerServices/ReadOnlyCollectionBuilder.cs +++ b/src/System.Linq.Expressions/src/System/Runtime/CompilerServices/ReadOnlyCollectionBuilder.cs @@ -397,7 +397,7 @@ object System.Collections.ICollection.SyncRoot { if (_syncRoot == null) { - System.Threading.Interlocked.CompareExchange(ref _syncRoot, new Object(), null); + System.Threading.Interlocked.CompareExchange(ref _syncRoot, new Object(), comparand: null); } return _syncRoot; }