private void HandleCastArgument(TypeReference parameterType, ExplicitCastExpression castArgument)
{
if (parameterType.FullName == currentTypeSystem.Char.FullName && castArgument.ExpressionType.FullName == currentTypeSystem.UInt16.FullName)
{
castArgument.TargetType = currentTypeSystem.Char;
}
}
private void MarkDynamicArguments(CallSiteInfo callSiteInfo, IList <Expression> arguments)
{
V_0 = callSiteInfo.get_DynamicArgumentIndices().GetEnumerator();
try
{
while (V_0.MoveNext())
{
V_1 = V_0.get_Current();
if (arguments.get_Item(V_1).get_CodeNodeType() == 24 || arguments.get_Item(V_1).get_CodeNodeType() == 23 && (arguments.get_Item(V_1) as UnaryExpression).get_Operator() == 11 || arguments.get_Item(V_1).get_CodeNodeType() == 61 || arguments.get_Item(V_1).get_CodeNodeType() == 59 || DynamicElementAnalyzer.Analyze(arguments.get_Item(V_1)))
{
continue;
}
V_2 = new ExplicitCastExpression(arguments.get_Item(V_1), this.objectTypeRef, null);
stackVariable40 = new Boolean[1];
stackVariable40[0] = true;
V_2.set_DynamicPositioningFlags(stackVariable40);
arguments.set_Item(V_1, V_2);
}
}
finally
{
((IDisposable)V_0).Dispose();
}
return;
}
private static Expression HandleAverage(HandlerContext handlerContext)
{
if (!handlerContext.QueryModelVisitor.RequiresClientProjection &&
handlerContext.SelectExpression.Projection.Count == 1)
{
var expression = handlerContext.SelectExpression.Projection.First();
if (!(expression.RemoveConvert() is SelectExpression))
{
var inputType = expression.Type;
var outputType = expression.Type;
var nonNullableInputType = inputType.UnwrapNullableType();
if (nonNullableInputType == typeof(int) ||
nonNullableInputType == typeof(long))
{
outputType = inputType.IsNullableType() ? typeof(double?) : typeof(double);
}
expression = new ExplicitCastExpression(expression, outputType);
var averageExpression = new SqlFunctionExpression("AVG", expression.Type, new [] { expression });
handlerContext.SelectExpression.SetProjectionExpression(averageExpression);
return((Expression)_transformClientExpressionMethodInfo
.MakeGenericMethod(averageExpression.Type)
.Invoke(null, new object [] { handlerContext }));
}
}
return(handlerContext.EvalOnClient());
}
private VariableReference GetTypeArrayVariable(MethodInvocationExpression binderMethodInvocation)
{
int typeArrayArgumentIndex = 2;
Expression typeArrayArgument = binderMethodInvocation.Arguments[typeArrayArgumentIndex];
if (typeArrayArgument.CodeNodeType == CodeNodeType.LiteralExpression &&
(typeArrayArgument as LiteralExpression).Value == null)
{
return(null);
}
VariableReferenceExpression typeArrayVariableReference = null;
if (typeArrayArgument.CodeNodeType == CodeNodeType.VariableReferenceExpression)
{
typeArrayVariableReference = typeArrayArgument as VariableReferenceExpression;
}
else if (typeArrayArgument.CodeNodeType == CodeNodeType.ExplicitCastExpression)
{
ExplicitCastExpression cast = typeArrayArgument as ExplicitCastExpression;
if (cast.ExpressionType.GetFriendlyFullName(null) == IEnumerableOfSystemType &&
cast.Expression.CodeNodeType == CodeNodeType.VariableReferenceExpression)
{
typeArrayVariableReference = cast.Expression as VariableReferenceExpression;
}
}
if (typeArrayVariableReference == null)
{
throw new Exception("Invalid argument: typeArguments.");
}
return(typeArrayVariableReference.Variable);
}
private void CastMethodArguments(MethodReference method, ExpressionCollection arguments)
{
for (int i = 0; i < arguments.Count; i++)
{
Expression argument = arguments[i];
TypeReference parameterType = method.Parameters[i].ResolveParameterType(method);
if (argument.HasType && parameterType != null && !(argument is LiteralExpression))
{
TypeReference argumentType = argument.ExpressionType;
if ((IsUnsignedIntegerType(argumentType) && IsSignedIntegerType(parameterType)) || (IsSignedIntegerType(argumentType) && IsUnsignedIntegerType(parameterType)))
{
Expression toCast = argument;
if (argument is ExplicitCastExpression)
{
ExplicitCastExpression argumentCast = argument as ExplicitCastExpression;
if (IsIntegerType(argumentCast.TargetType))
{
toCast = argumentCast.Expression;
}
}
arguments[i] = new ExplicitCastExpression(toCast, parameterType, null);
}
}
}
}
private bool TryGetMethodReference(Expression expression, string castTargetTypeName, out MethodReference methodRef)
{
methodRef = null;
ExplicitCastExpression cast = expression as ExplicitCastExpression;
if (cast == null || cast.Expression.CodeNodeType != CodeNodeType.MethodInvocationExpression ||
cast.TargetType == null || cast.TargetType.FullName != castTargetTypeName)
{
return(false);
}
MethodInvocationExpression methodInvoke = cast.Expression as MethodInvocationExpression;
if (methodInvoke == null || methodInvoke.Arguments.Count > 2 || methodInvoke.Arguments.Count < 1 || methodInvoke.Arguments[0].CodeNodeType != CodeNodeType.MemberHandleExpression ||
methodInvoke.Arguments.Count == 2 && methodInvoke.Arguments[1].CodeNodeType != CodeNodeType.MemberHandleExpression || methodInvoke.MethodExpression.Method == null ||
methodInvoke.MethodExpression.Method.Name != "GetMethodFromHandle" || methodInvoke.MethodExpression.Method.DeclaringType == null ||
methodInvoke.MethodExpression.Method.DeclaringType.FullName != "System.Reflection.MethodBase")
{
return(false);
}
methodRef = (methodInvoke.Arguments[0] as MemberHandleExpression).MemberReference as MethodReference;
return(methodRef != null);
}
private Expression FixCaseLiteralValue(LiteralExpression literalCondition)
{
V_0 = this.theSwitch.get_Condition().get_ExpressionType();
V_1 = Convert.ToInt32(literalCondition.get_Value()) + this.conditionOffset;
literalCondition.set_Value(V_1);
V_2 = this.context.get_MethodContext().get_Method().get_Module().get_TypeSystem();
if (String.op_Equality(V_0.get_Name(), "System.Nullable`1") && V_0.get_HasGenericParameters())
{
V_0 = V_0.get_GenericParameters().get_Item(0);
}
if (String.op_Equality(V_0.get_FullName(), V_2.get_Char().get_FullName()))
{
return(new LiteralExpression((object)Convert.ToChar(V_1), V_2, null));
}
if (String.op_Equality(V_0.get_FullName(), V_2.get_Boolean().get_FullName()))
{
return(new LiteralExpression((object)Convert.ToBoolean(V_1), V_2, null));
}
V_3 = V_0.Resolve();
if (V_3 == null || !V_3.get_IsEnum())
{
return(literalCondition);
}
V_4 = EnumHelper.GetEnumExpression(V_3, literalCondition, V_2);
if (V_4 as LiteralExpression != null)
{
V_4 = new ExplicitCastExpression(V_4, V_3, null);
}
return(V_4);
}
private VariableReference GetArgumentArrayVariable(MethodInvocationExpression binderMethodInvocation)
{
int argumentArrayIndex = binderMethodInvocation.Arguments.Count - 1;
Expression argumentArrayExpression = binderMethodInvocation.Arguments[argumentArrayIndex];
VariableReferenceExpression argumentArrayVariableReference = null;
if (argumentArrayExpression.CodeNodeType == CodeNodeType.VariableReferenceExpression)
{
argumentArrayVariableReference = argumentArrayExpression as VariableReferenceExpression;
}
else if (argumentArrayExpression.CodeNodeType == CodeNodeType.ExplicitCastExpression)
{
ExplicitCastExpression cast = argumentArrayExpression as ExplicitCastExpression;
if (cast.ExpressionType.GetFriendlyFullName(null) == IEnumerableOfCSharpArgumentInfo &&
cast.Expression.CodeNodeType == CodeNodeType.VariableReferenceExpression)
{
argumentArrayVariableReference = cast.Expression as VariableReferenceExpression;
}
}
if (argumentArrayVariableReference == null)
{
throw new Exception("Invalid argument: argumentInfo.");
}
return(argumentArrayVariableReference.Variable);
}
public override ICodeNode VisitBoxExpression(BoxExpression node)
{
base.VisitBoxExpression(node);
if (node.BoxedExpression.CodeNodeType == CodeNodeType.LiteralExpression && node.BoxedAs.FullName == currentTypeSystem.Boolean.FullName)
{
FixBooleanLiteral(node.BoxedExpression as LiteralExpression);
return(node.BoxedExpression.CloneAndAttachInstructions(node.MappedInstructions));
}
if (node.BoxedExpression.CodeNodeType == CodeNodeType.ExplicitCastExpression && ((ExplicitCastExpression)node.BoxedExpression).Expression.CodeNodeType == CodeNodeType.ExplicitCastExpression)
{
// double cast in a boxed expression;
ExplicitCastExpression outerCast = node.BoxedExpression as ExplicitCastExpression;
ExplicitCastExpression innerCast = outerCast.Expression as ExplicitCastExpression;
if (outerCast.TargetType.FullName == currentTypeSystem.Char.FullName &&
innerCast.TargetType.FullName == currentTypeSystem.UInt16.FullName)
{
// Remove the outer cast, as it is produced by the box expression and doesn't have any instructions mapped.
// The inner cast contains the instruction, converting the stack value to 2-byte integer (which at this point is known to be char, not ushort).
innerCast.TargetType = currentTypeSystem.Char;
node.BoxedExpression = innerCast;
}
}
return(node);
}
public override ICodeNode VisitReturnExpression(ReturnExpression node)
{
base.VisitReturnExpression(node);
LiteralExpression literalValue = node.Value as LiteralExpression;
if (literalValue != null)
{
if (isBoolReturnType)
{
FixBooleanLiteral(literalValue);
}
else if (isCharReturnType)
{
FixCharLiteral(literalValue);
}
}
ExplicitCastExpression castValue = node.Value as ExplicitCastExpression;
if (castValue != null)
{
if (castValue.ExpressionType.FullName != methodContext.Method.ReturnType.FullName)
{
if (isCharReturnType && castValue.ExpressionType.FullName == currentTypeSystem.UInt16.FullName)
{
castValue.TargetType = currentTypeSystem.Char;
}
}
}
return(node);
}
private void FixArguments(MethodReference method, ExpressionCollection arguments)
{
TypeDefinition declaringTypeDefinition = method.DeclaringType.Resolve();
if (declaringTypeDefinition == null)
{
return;
}
List <MethodDefinition> sameNameMethods = GetSameNameMethods(declaringTypeDefinition, method, arguments);
if (sameNameMethods.Count > 0)
{
for (int i = 0; i < arguments.Count; i++)
{
TypeReference paramType = method.Parameters[i].ResolveParameterType(method);
if (!arguments[i].HasType)
{
continue;
}
if (arguments[i].ExpressionType.FullName == paramType.FullName)
{
continue;
}
if (ShouldAddCast(arguments[i], sameNameMethods, i, paramType))
{
arguments[i] = new ExplicitCastExpression(arguments[i], paramType, null);
}
}
}
}
private void HandleCastArgument(TypeReference parameterType, ExplicitCastExpression castArgument)
{
if (String.op_Equality(parameterType.get_FullName(), this.currentTypeSystem.get_Char().get_FullName()) && String.op_Equality(castArgument.get_ExpressionType().get_FullName(), this.currentTypeSystem.get_UInt16().get_FullName()))
{
castArgument.set_TargetType(this.currentTypeSystem.get_Char());
}
return;
}
public override void VisitExplicitCastExpression(ExplicitCastExpression node)
{
TypesDependingOn.UnionWith(Utilities.GetTypeReferenceTypesDepedningOn(node.ExpressionType));
if (node.UnresolvedReferenceForAmbiguousCastToObject != null)
{
this.AmbiguousCastsToObject.Add(node);
}
base.VisitExplicitCastExpression(node);
}
public override void VisitExplicitCastExpression(ExplicitCastExpression node)
{
this.get_TypesDependingOn().UnionWith(Utilities.GetTypeReferenceTypesDepedningOn(node.get_ExpressionType()));
if (node.get_UnresolvedReferenceForAmbiguousCastToObject() != null)
{
dummyVar0 = this.get_AmbiguousCastsToObject().Add(node);
}
this.VisitExplicitCastExpression(node);
return;
}
public override ICodeNode VisitExplicitCastExpression(ExplicitCastExpression node)
{
if (node.get_Expression().get_CodeNodeType() != 22)
{
return(this.VisitExplicitCastExpression(node));
}
V_0 = node.get_ExpressionType().Resolve();
if (V_0 == null || !V_0.get_IsEnum() || node.get_ExpressionType().get_IsArray())
{
return(node);
}
return(EnumHelper.GetEnumExpression(node.get_ExpressionType().Resolve(), node.get_Expression() as LiteralExpression, this.typeSystem));
}
/// <summary>
/// This is an internal API that supports the Entity Framework Core infrastructure and not subject to
/// the same compatibility standards as public APIs. It may be changed or removed without notice in
/// any release. You should only use it directly in your code with extreme caution and knowing that
/// doing so can result in application failures when updating to a new Entity Framework Core release.
/// </summary>
public virtual Expression Translate(
MethodCallExpression methodCallExpression,
IDiagnosticsLogger <DbLoggerCategory.Query> logger)
{
Check.NotNull(methodCallExpression, nameof(methodCallExpression));
var method = methodCallExpression.Method;
if (_supportedMethodTranslations.TryGetValue(method, out var sqlFunctionName))
{
return(new SqlFunctionExpression(
sqlFunctionName,
methodCallExpression.Type,
methodCallExpression.Arguments));
}
if (_truncateMethodInfos.Contains(method))
{
var firstArgument = methodCallExpression.Arguments[0];
if (firstArgument.NodeType == ExpressionType.Convert)
{
firstArgument = new ExplicitCastExpression(firstArgument, firstArgument.Type);
}
return(new SqlFunctionExpression(
"ROUND",
methodCallExpression.Type,
new[] { firstArgument, Expression.Constant(0), Expression.Constant(1) }));
}
if (_roundMethodInfos.Contains(method))
{
var firstArgument = methodCallExpression.Arguments[0];
if (firstArgument.NodeType == ExpressionType.Convert)
{
firstArgument = new ExplicitCastExpression(firstArgument, firstArgument.Type);
}
return(new SqlFunctionExpression(
"ROUND",
methodCallExpression.Type,
methodCallExpression.Arguments.Count == 1
? new[] { firstArgument, Expression.Constant(0) }
: new[] { firstArgument, methodCallExpression.Arguments[1] }));
}
return(null);
}
public override ICodeNode VisitExplicitCastExpression(ExplicitCastExpression node)
{
if (node.get_Expression().get_CodeNodeType() == 22 && String.op_Equality(node.get_TargetType().get_FullName(), this.currentTypeSystem.get_Boolean().get_FullName()))
{
this.FixBooleanLiteral(node.get_Expression() as LiteralExpression);
return(node.get_Expression().CloneAndAttachInstructions(node.get_MappedInstructions()));
}
if (node.get_Expression().get_CodeNodeType() != 22 || !String.op_Equality(node.get_TargetType().get_FullName(), this.currentTypeSystem.get_Char().get_FullName()))
{
return(this.VisitExplicitCastExpression(node));
}
this.FixCharLiteral(node.get_Expression() as LiteralExpression);
return(node.get_Expression().CloneAndAttachInstructions(node.get_MappedInstructions()));
}
public virtual Expression Translate(MethodCallExpression methodCallExpression)
{
Check.NotNull(methodCallExpression, nameof(methodCallExpression));
var method = methodCallExpression.Method;
if (_supportedMethodTranslations.TryGetValue(method, out string sqlFunctionName))
{
return(new SqlFunctionExpression(
sqlFunctionName,
methodCallExpression.Type,
methodCallExpression.Arguments));
}
if (_truncateMethodInfos.Contains(method))
{
var firstArgument = methodCallExpression.Arguments[0];
if (firstArgument.NodeType == ExpressionType.Convert)
{
firstArgument = new ExplicitCastExpression(firstArgument, firstArgument.Type);
}
return(new SqlFunctionExpression(
"TRUNC",
methodCallExpression.Type,
new[] { firstArgument }));
}
if (_roundMethodInfos.Contains(method))
{
var firstArgument = methodCallExpression.Arguments[0];
if (firstArgument.NodeType == ExpressionType.Convert)
{
firstArgument = new ExplicitCastExpression(firstArgument, firstArgument.Type);
}
return(new SqlFunctionExpression(
"ROUND",
methodCallExpression.Type,
methodCallExpression.Arguments.Count == 1
? new[] { firstArgument }
: new[] { firstArgument, methodCallExpression.Arguments[1] }));
}
return(null);
}
private void MarkDynamicArguments(CallSiteInfo callSiteInfo, IList <Expression> arguments)
{
foreach (int index in callSiteInfo.DynamicArgumentIndices)
{
if (arguments[index].CodeNodeType != CodeNodeType.BinaryExpression &&
(arguments[index].CodeNodeType != CodeNodeType.UnaryExpression || (arguments[index] as UnaryExpression).Operator != UnaryOperator.None) &&
arguments[index].CodeNodeType != CodeNodeType.DynamicIndexerExpression &&
arguments[index].CodeNodeType != CodeNodeType.DynamicMemberReferenceExpression &&
!DynamicElementAnalyzer.Analyze(arguments[index]))
{
ExplicitCastExpression theCastExpression = new ExplicitCastExpression(arguments[index], objectTypeRef, null);
theCastExpression.DynamicPositioningFlags = new bool[] { true };
arguments[index] = theCastExpression;
}
}
}
public override ICodeNode VisitExplicitCastExpression(ExplicitCastExpression node)
{
if (node.Expression.CodeNodeType == CodeNodeType.LiteralExpression && node.TargetType.FullName == currentTypeSystem.Boolean.FullName)
{
FixBooleanLiteral(node.Expression as LiteralExpression);
return(node.Expression.CloneAndAttachInstructions(node.MappedInstructions));
}
if (node.Expression.CodeNodeType == CodeNodeType.LiteralExpression && node.TargetType.FullName == currentTypeSystem.Char.FullName)
{
FixCharLiteral(node.Expression as LiteralExpression);
return(node.Expression.CloneAndAttachInstructions(node.MappedInstructions));
}
return(base.VisitExplicitCastExpression(node));
}
public override ICodeNode VisitExplicitCastExpression(ExplicitCastExpression node)
{
if (node.Expression.CodeNodeType == CodeNodeType.LiteralExpression)
{
TypeDefinition typeDef = node.ExpressionType.Resolve();
if (typeDef != null && typeDef.IsEnum && !node.ExpressionType.IsArray)
{
return(EnumHelper.GetEnumExpression(node.ExpressionType.Resolve(), node.Expression as LiteralExpression, typeSystem));
}
return(node);
}
else
{
return(base.VisitExplicitCastExpression(node));
}
}
private void CheckArguments(Mono.Collections.Generic.Collection <ParameterDefinition> parameters, ExpressionCollection arguments)
{
for (int i = 0; i < arguments.Count; i++)
{
Expression argument = arguments[i];
if (argument.HasType)
{
TypeDefinition argumentType = argument.ExpressionType.Resolve();
TypeReference parameterType = parameters[i].ParameterType;
if (ShouldAddCast(argumentType, parameterType))
{
arguments[i] = new ExplicitCastExpression(argument, parameterType, null);
}
}
}
}
private static Expression HandleAverage(HandlerContext handlerContext)
{
if (!handlerContext.QueryModelVisitor.RequiresClientProjection &&
handlerContext.SelectExpression.Projection.Count == 1)
{
PrepareSelectExpressionForAggregate(handlerContext.SelectExpression);
var expression = handlerContext.SelectExpression.Projection.First();
if (!(expression.RemoveConvert() is SelectExpression))
{
var inputType = handlerContext.QueryModel.SelectClause.Selector.Type;
var outputType = inputType;
var nonNullableInputType = inputType.UnwrapNullableType();
if (nonNullableInputType == typeof(int) ||
nonNullableInputType == typeof(long))
{
outputType = inputType.IsNullableType() ? typeof(double?) : typeof(double);
}
expression = (expression as ExplicitCastExpression)?.Operand ?? expression;
expression = UnwrapAliasExpression(expression);
expression = new ExplicitCastExpression(expression, outputType);
Expression averageExpression = new SqlFunctionExpression(
"AVG",
outputType,
new[] { expression });
if (nonNullableInputType == typeof(float))
{
averageExpression = new ExplicitCastExpression(averageExpression, inputType);
}
handlerContext.SelectExpression.SetProjectionExpression(averageExpression);
var averageExpressionType = averageExpression.Type;
var throwOnNullResult = DetermineAggregateThrowingBehavior(handlerContext, averageExpressionType);
return((Expression)_transformClientExpressionMethodInfo
.MakeGenericMethod(averageExpressionType)
.Invoke(null, new object[] { handlerContext, throwOnNullResult }));
}
}
return(handlerContext.EvalOnClient());
}
public override Expression VisitExplicitCast(ExplicitCastExpression explicitCastExpression)
{
var typeMapping = _typeMapper.FindMappingForExplicitCast(explicitCastExpression.Type);
if (typeMapping == null)
{
throw new InvalidOperationException(RelationalStrings.UnsupportedType(explicitCastExpression.Type.Name));
}
Sql.Append("CAST(");
Visit(explicitCastExpression.Operand);
Sql.Append(" AS ");
Sql.Append(typeMapping.StoreType);
Sql.Append(")");
return(explicitCastExpression);
}
public virtual Expression Translate(MethodCallExpression methodCallExpression)
{
var method = methodCallExpression.Method;
if (SupportedMethodTranslations.TryGetValue(method, out var sqlFunctionName))
{
return(new SqlFunctionExpression(
sqlFunctionName,
methodCallExpression.Type,
methodCallExpression.Arguments));
}
if (TruncateMethodInfos.Contains(method))
{
var firstArgument = methodCallExpression.Arguments[0];
if (firstArgument.NodeType == ExpressionType.Convert)
{
firstArgument = new ExplicitCastExpression(firstArgument, firstArgument.Type);
}
return(new SqlFunctionExpression(
"TRUNC",
methodCallExpression.Type,
new[] { firstArgument, Expression.Constant(0) }));
}
if (RoundMethodInfos.Contains(method))
{
var firstArgument = methodCallExpression.Arguments[0];
if (firstArgument.NodeType == ExpressionType.Convert)
{
firstArgument = new ExplicitCastExpression(firstArgument, firstArgument.Type);
}
return(new SqlFunctionExpression(
"ROUND",
methodCallExpression.Type,
methodCallExpression.Arguments.Count == 1
? new[] { firstArgument, Expression.Constant(0) }
: new[] { firstArgument, methodCallExpression.Arguments[1] }));
}
return(null);
}
public override ICodeNode VisitUnaryExpression(UnaryExpression node)
{
if (node.Operator == UnaryOperator.AddressDereference)
{
if (node.Operand.CodeNodeType == CodeNodeType.ThisReferenceExpression)
{
return(node.Operand);
}
ExplicitCastExpression castOperand = node.Operand as ExplicitCastExpression;
if (castOperand != null && castOperand.TargetType.IsByReference)
{
TypeReference targetType = (castOperand.TargetType as ByReferenceType).ElementType;
return(new ExplicitCastExpression((Expression)Visit(castOperand.Expression), targetType, null));
}
}
return(base.VisitUnaryExpression(node));
}
public override Expression VisitExplicitCast(ExplicitCastExpression explicitCastExpression)
{
Sql.Append("CAST(");
Visit(explicitCastExpression.Operand);
Sql.Append(" AS ");
var typeMapping = Dependencies.TypeMappingSource.FindMapping(explicitCastExpression.Type);
if (typeMapping == null)
{
throw new InvalidOperationException($"Cannot cast to type '{explicitCastExpression.Type.Name}'");
}
var storeTypeLower = typeMapping.StoreType.ToLower();
string castMapping = null;
foreach (var kvp in CastMappings)
{
foreach (var storeType in kvp.Value)
{
if (storeTypeLower.StartsWith(storeType))
{
castMapping = kvp.Key;
break;
}
}
if (castMapping != null)
{
break;
}
}
if (castMapping == "signed" && storeTypeLower.Contains("unsigned"))
{
castMapping = "unsigned";
}
else if (castMapping == null)
{
castMapping = "char";
}
Sql.Append(castMapping);
Sql.Append(")");
return(explicitCastExpression);
}
public override void VisitReturnExpression(ReturnExpression node)
{
base.VisitReturnExpression(node);
if (decompiledMethodReturnType != null && node.Value != null && node.Value.HasType && ShouldAddCastToAssignment(decompiledMethodReturnType, node.Value.ExpressionType))
{
Expression toCast = node.Value;
if (node.Value is ExplicitCastExpression)
{
ExplicitCastExpression valueCast = node.Value as ExplicitCastExpression;
if (IsIntegerType(valueCast.TargetType))
{
toCast = valueCast.Expression;
}
}
node.Value = new ExplicitCastExpression(toCast, decompiledMethodReturnType, null);
}
}
private void VisitInvocationArguments(ExpressionCollection arguments, MethodReference method)
{
Collection <ParameterDefinition> parameters = method.Parameters;
for (int index = 0; index < arguments.Count; index++)
{
TypeReference paramType = parameters[index].ResolveParameterType(method);
if (NeedsCast(arguments[index].ExpressionType, paramType))
{
if (arguments[index].CodeNodeType == CodeNodeType.LiteralExpression)
{
arguments[index] = EnumHelper.GetEnumExpression(paramType.Resolve(), (arguments[index] as LiteralExpression), typeSystem);
}
else
{
arguments[index] = new ExplicitCastExpression(arguments[index], paramType, null);
}
}
}
}
/// <summary>
/// 访问CAST AS表达式。
/// </summary>
/// <param name="explicitCastExpression">表达式。</param>
/// <returns>返回访问后的表达式实例对象。</returns>
public Expression VisitExplicitCast(ExplicitCastExpression explicitCastExpression)
{
_builder.Append("CAST(");
Visit(explicitCastExpression.Operand);
_builder.Append(" AS ");
var typeMapping = _typeMapper.GetMapping(explicitCastExpression.Type);
if (typeMapping == null)
{
throw new InvalidOperationException(string.Format(Resources.UnsupportedType, explicitCastExpression.Type.DisplayName(false)));
}
_builder.Append(typeMapping);
_builder.Append(")");
return(explicitCastExpression);
}
