Conversion ExplicitConversion(Type from, Type to)
{
IType from2 = compilation.FindType(from);
IType to2 = compilation.FindType(to);
return(conversions.ExplicitConversion(from2, to2));
}
void VisitTypeCastExpression(AssignmentExpression expression, IType exprType, IType castToType)
{
if (exprType.Kind == TypeKind.Unknown || castToType.Kind == TypeKind.Unknown)
{
return;
}
var foundConversion = conversion.ExplicitConversion(exprType, castToType);
if (foundConversion == Conversion.None)
{
return;
}
if (!foundConversion.IsExplicit)
{
return;
}
var implicitConversion = conversion.ImplicitConversion(exprType, castToType);
if (implicitConversion != Conversion.None)
{
return;
}
AddIssue(expression, string.Format(ctx.TranslateString("Cast to '{0}'"), castToType.Name),
script => {
var right = expression.Right.Clone();
var castRight = right.CastTo(CreateShortType(expression, castToType));
script.Replace(expression.Right, castRight);
});
}
void VisitTypeCastExpression(Expression expression, IType exprType, IType castToType)
{
if (exprType.Kind == TypeKind.Unknown || castToType.Kind == TypeKind.Unknown || castToType.Kind == TypeKind.TypeParameter)
{
return;
}
var foundConversion = conversion.ExplicitConversion(exprType, castToType);
if (foundConversion == Conversion.None)
{
AddIssue(new CodeIssue(expression, ctx.TranslateString("Type cast expression of incompatible type")));
}
}
void CheckConversion(IType variableType, Expression expression)
{
if (variableType.Kind == TypeKind.Unknown)
{
return; // ignore error if the variable type is unknown
}
if (ctx.GetConversion(expression).IsValid)
{
return; // don't complain if the code is valid
}
var rr = ctx.Resolve(expression);
if (rr.Type.Kind == TypeKind.Unknown)
{
return; // ignore error if expression type is unknown
}
var foundConversion = conversion.ExplicitConversion(rr, variableType);
var builder = ctx.CreateTypeSystemAstBuilder(expression);
AstType variableTypeNode = builder.ConvertType(variableType);
AstType expressionTypeNode = builder.ConvertType(rr.Type);
if (foundConversion.IsValid)
{
// CS0266: An explicit conversion exists -> suggested fix is to insert the cast
string title = string.Format(ctx.TranslateString("Cannot implicitly convert type `{0}' to `{1}'. An explicit conversion exists (are you missing a cast?)"),
expressionTypeNode, variableTypeNode);
string fixTitle = string.Format(ctx.TranslateString("Cast to '{0}'"), variableTypeNode);
Action <Script> fixAction = script => {
var right = expression.Clone();
var castRight = right.CastTo(variableTypeNode);
script.Replace(expression, castRight);
};
AddIssue(expression, title, new CodeAction(fixTitle, fixAction, expression));
}
else
{
// CS0029: No explicit conversion -> Issue without suggested fix
string title = string.Format(ctx.TranslateString("Cannot implicitly convert type `{0}' to `{1}'"),
expressionTypeNode, variableTypeNode);
AddIssue(expression, title);
}
}
bool IsValidReferenceOrBoxingConversion(IType fromType, IType toType)
{
Conversion c = conversions.ExplicitConversion(fromType, toType);
return(c.IsValid && (c.IsIdentityConversion || c.IsReferenceConversion || c.IsBoxingConversion || c.IsUnboxingConversion));
}
void CheckConversion(IType variableType, Expression expression)
{
if (variableType.Kind == TypeKind.Unknown)
{
return; // ignore error if the variable type is unknown
}
if (ctx.GetConversion(expression).IsValid)
{
return; // don't complain if the code is valid
}
var rr = ctx.Resolve(expression);
if (rr.Type.Kind == TypeKind.Unknown)
{
return; // ignore error if expression type is unknown
}
var foundConversion = conversion.ExplicitConversion(rr, variableType);
var builder = ctx.CreateTypeSystemAstBuilder(expression);
AstType variableTypeNode = builder.ConvertType(variableType);
AstType expressionTypeNode = builder.ConvertType(rr.Type);
string title;
List <CodeAction> fixes = new List <CodeAction>();
if (foundConversion.IsValid)
{
// CS0266: An explicit conversion exists -> suggested fix is to insert the cast
title = string.Format(ctx.TranslateString("Cannot implicitly convert type `{0}' to `{1}'. An explicit conversion exists (are you missing a cast?)"),
expressionTypeNode, variableTypeNode);
string fixTitle = string.Format(ctx.TranslateString("Cast to '{0}'"), variableTypeNode);
Action <Script> fixAction = script => {
var right = expression.Clone();
var castRight = right.CastTo(variableTypeNode);
script.Replace(expression, castRight);
};
fixes.Add(new CodeAction(fixTitle, fixAction, expression));
}
else
{
// CS0029: No explicit conversion -> Issue without suggested fix
title = string.Format(ctx.TranslateString("Cannot implicitly convert type `{0}' to `{1}'"),
expressionTypeNode, variableTypeNode);
}
if (expression.Parent is VariableInitializer)
{
var fd = expression.Parent.Parent as FieldDeclaration;
if (fd != null)
{
fixes.Add(new CodeAction(
ctx.TranslateString("Change field type"),
script => {
script.Replace(fd.ReturnType, ctx.CreateTypeSystemAstBuilder(fd).ConvertType(rr.Type));
},
expression
));
}
var lc = expression.Parent.Parent as VariableDeclarationStatement;
if (lc != null)
{
fixes.Add(new CodeAction(
ctx.TranslateString("Change local variable type"),
script => {
script.Replace(lc.Type, new SimpleType("var"));
},
expression
));
}
}
if (expression.Parent is ReturnStatement)
{
AstNode entityNode;
var type = CS0126ReturnMustBeFollowedByAnyExpression.GetRequestedReturnType(ctx, expression.Parent, out entityNode);
if (type != null)
{
var entity = entityNode as EntityDeclaration;
if (entity != null)
{
fixes.Add(new CodeAction(
ctx.TranslateString("Change return type"),
script => {
script.Replace(entity.ReturnType, ctx.CreateTypeSystemAstBuilder(entity).ConvertType(rr.Type));
},
expression
));
}
}
}
AddIssue(new CodeIssue(expression, title, fixes));
}