public System.Collections.Generic.IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var catchClause = context.GetNode <CatchClause>();
if (catchClause == null)
{
yield break;
}
if (catchClause.Type.IsNull)
{
yield break;
}
var exceptionType = context.ResolveType(catchClause.Type);
if (exceptionType != context.Compilation.FindType(typeof(Exception)))
{
yield break;
}
var syntaxTree = context.RootNode as SyntaxTree;
if (syntaxTree == null)
{
yield break;
}
var exceptionIdentifierRR = context.Resolve(catchClause.VariableNameToken) as LocalResolveResult;
if (exceptionIdentifierRR != null &&
IsReferenced(exceptionIdentifierRR.Variable, catchClause.Body, syntaxTree, context))
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Remove type specifier"), script =>
{
script.Replace(catchClause, new CatchClause()
{
Body = catchClause.Body.Clone() as BlockStatement
});
}));
}
protected override CodeAction GetAction(RefactoringContext context, ParameterDeclaration parameter)
{
if (!parameter.NameToken.Contains(context.Location))
{
return(null);
}
BlockStatement bodyStatement;
if (parameter.Parent is LambdaExpression)
{
bodyStatement = parameter.Parent.GetChildByRole(LambdaExpression.BodyRole) as BlockStatement;
}
else
{
bodyStatement = parameter.Parent.GetChildByRole(Roles.Body);
}
if (bodyStatement == null || bodyStatement.IsNull)
{
return(null);
}
var type = context.ResolveType(parameter.Type);
if (type.IsReferenceType == false || HasNullCheck(parameter))
{
return(null);
}
return(new CodeAction(context.TranslateString("Add null check for parameter"), script => {
var statement = new IfElseStatement()
{
Condition = new BinaryOperatorExpression(new IdentifierExpression(parameter.Name), BinaryOperatorType.Equality, new NullReferenceExpression()),
TrueStatement = new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "ArgumentNullException"), new PrimitiveExpression(parameter.Name)))
};
script.AddTo(bodyStatement, statement);
}, parameter.NameToken));
}
protected override CodeAction GetAction(RefactoringContext context, VariableInitializer node)
{
if (node.Initializer.IsNull)
{
return(null);
}
var variableDecl = node.Parent as VariableDeclarationStatement;
if (variableDecl == null || !(variableDecl.Parent is BlockStatement))
{
return(null);
}
var type = context.ResolveType(variableDecl.Type);
if (!IsIDisposable(type))
{
return(null);
}
var unit = context.RootNode as SyntaxTree;
if (unit == null)
{
return(null);
}
var resolveResult = (LocalResolveResult)context.Resolve(node);
return(new CodeAction(context.TranslateString("put inside 'using'"),
script =>
{
var lastReference = GetLastReference(resolveResult.Variable, context, unit);
var body = new BlockStatement();
var variableToMoveOutside = new List <VariableDeclarationStatement> ();
if (lastReference != node)
{
var statements = CollectStatements(variableDecl.GetNextSibling(n => n is Statement) as Statement,
lastReference.EndLocation).ToArray();
// collect statements to put inside 'using' and variable declaration to move outside 'using'
foreach (var statement in statements)
{
script.Remove(statement);
var decl = statement as VariableDeclarationStatement;
if (decl == null)
{
body.Statements.Add(statement.Clone());
continue;
}
var outsideDecl = (VariableDeclarationStatement)decl.Clone();
outsideDecl.Variables.Clear();
var insideDecl = (VariableDeclarationStatement)outsideDecl.Clone();
foreach (var variable in decl.Variables)
{
var reference = GetLastReference(
((LocalResolveResult)context.Resolve(variable)).Variable, context, unit);
if (reference.StartLocation > lastReference.EndLocation)
{
outsideDecl.Variables.Add((VariableInitializer)variable.Clone());
}
else
{
insideDecl.Variables.Add((VariableInitializer)variable.Clone());
}
}
if (outsideDecl.Variables.Count > 0)
{
variableToMoveOutside.Add(outsideDecl);
}
if (insideDecl.Variables.Count > 0)
{
body.Statements.Add(insideDecl);
}
}
}
foreach (var decl in variableToMoveOutside)
{
script.InsertBefore(variableDecl, decl);
}
if (body.Statements.Count > 0)
{
var lastStatement = body.Statements.Last();
if (IsDisposeInvocation(resolveResult.Variable.Name, lastStatement))
{
lastStatement.Remove();
}
}
var usingStatement = new UsingStatement
{
ResourceAcquisition = new VariableDeclarationStatement(variableDecl.Type.Clone(), node.Name,
node.Initializer.Clone()),
EmbeddedStatement = body
};
script.Replace(variableDecl, usingStatement);
if (variableDecl.Variables.Count == 1)
{
return;
}
// other variables in the same declaration statement
var remainingVariables = (VariableDeclarationStatement)variableDecl.Clone();
remainingVariables.Variables.Remove(
remainingVariables.Variables.FirstOrDefault(v => v.Name == node.Name));
script.InsertBefore(usingStatement, remainingVariables);
}, node.NameToken));
}
static Expression GetDefaultValueExpression(RefactoringContext context, AstType astType)
{
var type = context.ResolveType(astType);
// array
if (type.Kind == TypeKind.Array)
{
return(new ObjectCreateExpression(astType.Clone()));
}
// enum
if (type.Kind == TypeKind.Enum)
{
var members = type.GetMembers().ToArray();
if (members.Length == 0)
{
return(new DefaultValueExpression(astType.Clone()));
}
return(astType.Member(members[0].Name, null).Clone());
}
if ((type.IsReferenceType ?? false) || type.Kind == TypeKind.Dynamic)
{
return(new NullReferenceExpression());
}
var typeDefinition = type.GetDefinition();
if (typeDefinition != null)
{
switch (typeDefinition.KnownTypeCode)
{
case KnownTypeCode.Boolean:
return(new PrimitiveExpression(false));
case KnownTypeCode.Char:
return(new PrimitiveExpression('\0'));
case KnownTypeCode.SByte:
case KnownTypeCode.Byte:
case KnownTypeCode.Int16:
case KnownTypeCode.UInt16:
case KnownTypeCode.Int32:
case KnownTypeCode.UInt32:
case KnownTypeCode.Int64:
case KnownTypeCode.UInt64:
case KnownTypeCode.Single:
case KnownTypeCode.Double:
case KnownTypeCode.Decimal:
return(new PrimitiveExpression(0));
case KnownTypeCode.NullableOfT:
return(new NullReferenceExpression());
}
if (type.Kind == TypeKind.Struct)
{
return(new ObjectCreateExpression(astType.Clone()));
}
}
return(new DefaultValueExpression(astType.Clone()));
}
