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 CastExpression(arguments[i], paramType, null);
}
}
}
}
public override void VisitCastExpression(CastExpression node)
{
TypesDependingOn.UnionWith(Utilities.GetTypeReferenceTypesDepedningOn(node.ExpressionType));
if (node.UnresolvedReferenceForAmbiguousCastToObject != null)
{
this.AmbiguousCastsToObject.Add(node);
}
base.VisitCastExpression(node);
}
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 CastExpression(arguments[index], paramType, null);
}
}
}
}
public override ICodeNode VisitCastExpression(CastExpression 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.VisitCastExpression(node);
}
}
public override Expression CloneExpressionOnly()
{
CastExpression result = new CastExpression(Expression.CloneExpressionOnly(), TargetType, null)
{
IsChecked = this.IsChecked,
IsExplicitInterfaceCast = this.IsExplicitInterfaceCast,
UnresolvedReferenceForAmbiguousCastToObject = this.UnresolvedReferenceForAmbiguousCastToObject
};
return result;
}
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 CastExpression)
{
CastExpression argumentCast = argument as CastExpression;
if (IsIntegerType(argumentCast.TargetType))
{
toCast = argumentCast.Expression;
}
}
arguments[i] = new CastExpression(toCast, parameterType, null);
}
}
}
}
private void WriteCastExpression(CastExpression node)
{
bool isComplexCastTarget = IsComplexTarget(node.Expression);
if (isComplexCastTarget)
{
WriteToken("(");
}
Visit(node.Expression);
if (isComplexCastTarget)
{
WriteToken(")");
}
}
public override ICodeNode VisitCastExpression(CastExpression 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.VisitCastExpression(node);
}
public override void VisitCastExpression(CastExpression node)
{
var castMethod = GetCastMethod(node.TargetType);
if (castMethod == null)
{
WriteKeyword("DirectCast");
WriteToken("(");
WriteCastExpression(node);
WriteToken(",");
WriteSpace();
WriteReferenceAndNamespaceIfInCollision(node.TargetType);
}
else
{
if (node.UnresolvedReferenceForAmbiguousCastToObject == null)
{
WriteKeyword(castMethod);
}
else
{
TypeReference lastResolvedType;
Common.Extensions.ResolveToOverloadedEqualityOperator(node.Expression.ExpressionType, out lastResolvedType);
WriteNotResolvedReference(castMethod, lastResolvedType, string.Format(CastToObjectResolvementError, lastResolvedType.Name));
}
WriteToken("(");
WriteCastExpression(node);
}
WriteToken(")");
}
public override void VisitCastExpression(CastExpression node)
{
if (node.IsChecked)
{
WriteKeyword(KeyWordWriter.Checked);
WriteToken("(");
}
WriteToken("(");
if (node.IsDynamic)
{
WriteDynamicType(node.TargetType, node.DynamicPositioningFlags);
}
else
{
if (node.UnresolvedReferenceForAmbiguousCastToObject == null)
{
WriteReferenceAndNamespaceIfInCollision(node.TargetType);
}
else
{
TypeReference lastResolvedType;
Common.Extensions.ResolveToOverloadedEqualityOperator(node.Expression.ExpressionType, out lastResolvedType);
WriteNotResolvedReference("object", lastResolvedType, string.Format(CastToObjectResolvementError, lastResolvedType.Name));
}
}
WriteToken(")");
bool isComplexCastTarget = IsComplexTarget(node.Expression);
if (isComplexCastTarget)
{
WriteToken("(");
}
Visit(node.Expression);
if (isComplexCastTarget)
{
WriteToken(")");
}
if (node.IsChecked)
{
WriteToken(")");
}
}
private void HandleCastArgument(TypeReference parameterType, CastExpression castArgument)
{
if (parameterType.FullName == currentTypeSystem.Char.FullName && castArgument.ExpressionType.FullName == currentTypeSystem.UInt16.FullName)
{
castArgument.TargetType = currentTypeSystem.Char;
}
}
public virtual void VisitCastExpression(CastExpression node)
{
Visit(node.Expression);
}
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]))
{
CastExpression theCastExpression = new CastExpression(arguments[index], objectTypeRef, null);
theCastExpression.DynamicPositioningFlags = new bool[] { true };
arguments[index] = theCastExpression;
}
}
}
public override ICodeNode VisitUnaryExpression(UnaryExpression node)
{
if (node.Operator == UnaryOperator.AddressDereference)
{
if (node.Operand is UnaryExpression)
{
UnaryExpression unaryOperand = node.Operand as UnaryExpression;
if (unaryOperand.Operator == UnaryOperator.AddressOf || unaryOperand.Operator == UnaryOperator.AddressReference)
{
return Visit(unaryOperand.Operand);
}
}
if (node.Operand is CastExpression && node.Operand.ExpressionType.IsByReference)
{
CastExpression theCast = node.Operand as CastExpression;
TypeReference targetType = (theCast.ExpressionType as ByReferenceType).ElementType;
CastExpression result = new CastExpression(theCast.Expression, targetType, theCast.MappedInstructions);
return Visit(result);
}
}
return base.VisitUnaryExpression(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 CastExpression(argument, parameterType, null);
}
}
}
}
private Expression FixCaseLiteralValue(LiteralExpression literalCondition)
{
TypeReference conditionType = theSwitch.Condition.ExpressionType;
int integerRepresentation = Convert.ToInt32(literalCondition.Value) + this.conditionOffset;
literalCondition.Value = integerRepresentation;
var theTypeSystem = context.MethodContext.Method.Module.TypeSystem;
if (conditionType.Name == "System.Nullable`1" && conditionType.HasGenericParameters)
{
conditionType = conditionType.GenericParameters[0];
}
if (conditionType.FullName == theTypeSystem.Char.FullName)
{
//switch cases should have char labels;
return new LiteralExpression(Convert.ToChar(integerRepresentation),theTypeSystem, null);
}
else if (conditionType.FullName == theTypeSystem.Boolean.FullName)
{
return new LiteralExpression(Convert.ToBoolean(integerRepresentation),theTypeSystem,null);
}
else
{
TypeDefinition resolvedConditionType = conditionType.Resolve();
if (resolvedConditionType != null && resolvedConditionType.IsEnum)
{
Expression result = EnumHelper.GetEnumExpression(resolvedConditionType,literalCondition,theTypeSystem);
if (result is LiteralExpression)
{
result = new CastExpression(result, resolvedConditionType, null);
}
return result;
}
}
return literalCondition;
}
