public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var variableDeclaration = context.GetNode <VariableDeclarationStatement>();
if (variableDeclaration == null)
{
yield break;
}
var entryNode = FindCurrentScopeEntryNode(variableDeclaration);
if (entryNode == null)
{
yield break;
}
var selectedInitializer = context.GetNode <VariableInitializer>();
if (selectedInitializer != null)
{
if (HasDependency(context, entryNode, selectedInitializer))
{
yield return(MoveDeclarationAction(context, entryNode, variableDeclaration, selectedInitializer));
}
else
{
yield return(MoveInitializerAction(context, entryNode, variableDeclaration, selectedInitializer));
}
}
else
{
yield return(new CodeAction(context.TranslateString("Move declaration to outer scope"), script => {
script.Remove(variableDeclaration);
script.InsertBefore(entryNode, variableDeclaration.Clone());
}));
}
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var invocation = context.GetNode <InvocationExpression>();
if (invocation == null)
{
yield break;
}
var memberReference = invocation.Target as MemberReferenceExpression;
if (memberReference == null)
{
yield break;
}
var invocationRR = context.Resolve(invocation) as CSharpInvocationResolveResult;
if (invocationRR == null)
{
yield break;
}
if (invocationRR.IsExtensionMethodInvocation)
{
yield return(new CodeAction(context.TranslateString("Convert to call to static method"), script => {
script.Replace(invocation, ToStaticMethodInvocation(invocation, memberReference, invocationRR));
}, invocation));
}
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var usingNode = FindUsingNodeAtCursor(context);
if (usingNode == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Sort usings"), script =>
{
var blocks = EnumerateUsingBlocks(context.RootNode);
foreach (var block in blocks)
{
var originalNodes = block.ToArray();
var sortedNodes = UsingHelper.SortUsingBlock(originalNodes, context).ToArray();
for (var i = 0; i < originalNodes.Length; ++i)
{
script.Replace(originalNodes[i], sortedNodes[i].Clone());
}
}
}, usingNode));
}
IEnumerable <CodeAction> GetAction <T, S> (RefactoringContext context, T decl,
Func <T, AstNodeCollection <S> > getInitializers)
where T : AstNode
where S : AstNode
{
var initializers = getInitializers(decl);
if (initializers.Count < 2)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Split declaration list"),
script =>
{
var emptyDecl = (T)decl.Clone();
getInitializers(emptyDecl).Clear();
var declList = initializers.Select(v =>
{
var singleDecl = (T)emptyDecl.Clone();
getInitializers(singleDecl).Add((S)v.Clone());
return singleDecl;
});
foreach (var singleDecl in declList)
{
script.InsertBefore(decl, singleDecl);
}
script.Remove(decl);
}, decl));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
if (context.IsSomethingSelected)
{
yield break;
}
var node = context.GetNode <VariableDeclarationStatement>();
if (node == null || node.Variables.Count != 1)
{
yield break;
}
var initializer = node.Variables.First();
if (!initializer.NameToken.Contains(context.Location) || initializer.Initializer.IsNull)
{
yield break;
}
var resolveResult = context.Resolve(initializer) as LocalResolveResult;
if (resolveResult == null || resolveResult.IsError)
{
yield break;
}
var unit = context.RootNode as SyntaxTree;
if (unit == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Inline local variable"), script => {
refFinder.FindLocalReferences(resolveResult.Variable, context.UnresolvedFile, unit, context.Compilation, (n, r) => script.Replace(n, AddParensIfRequired(n, initializer.Initializer.Clone())), default(CancellationToken));
script.Remove(node);
}, initializer));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode <PropertyDeclaration>();
if (property == null || !property.NameToken.Contains(context.Location))
{
yield break;
}
var field = GetBackingField(context, property);
if (field == null)
{
yield break;
}
// create new auto property
var newProperty = (PropertyDeclaration)property.Clone();
newProperty.Getter.Body = BlockStatement.Null;
newProperty.Setter.Body = BlockStatement.Null;
yield return(new CodeAction(context.TranslateString("Convert to auto property"), script => {
script.Rename((IEntity)field, newProperty.Name);
script.Remove(context.RootNode.GetNodeAt <FieldDeclaration> (field.Region.Begin));
script.Replace(property, newProperty);
}, property.NameToken));
}
protected override CodeAction GetAction(RefactoringContext context, ParameterDeclaration parameter)
{
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));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var catchClause = context.GetNode <CatchClause>();
if (catchClause == null)
{
yield break;
}
if (!catchClause.Type.IsNull)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Add type specifier"), script => {
var newIdentifier = Identifier.Create("e");
var newType = context.CreateShortType("System", "Exception");
script.Replace(catchClause, new CatchClause()
{
Type = newType,
VariableNameToken = newIdentifier,
Body = catchClause.Body.Clone() as BlockStatement
});
script.Link(newType);
script.Link(newIdentifier);
}));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var service = (CodeGenerationService)context.GetService(typeof(CodeGenerationService));
if (service == null)
{
yield break;
}
var type = context.GetNode <AstType>();
if (type == null || type.Role != Roles.BaseType)
{
yield break;
}
var state = context.GetResolverStateBefore(type);
if (state.CurrentTypeDefinition == null)
{
yield break;
}
var resolveResult = context.Resolve(type);
if (resolveResult.Type.Kind != TypeKind.Interface)
{
yield break;
}
bool interfaceMissing;
var toImplement = CollectMembersToImplement(state.CurrentTypeDefinition, resolveResult.Type, false, out interfaceMissing);
if (toImplement.Count == 0)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Implement interface"), script =>
script.InsertWithCursor(
context.TranslateString("Implement Interface"),
state.CurrentTypeDefinition,
(s, c) => GenerateImplementation(c, toImplement, interfaceMissing).ToList()
)
, type));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode <PropertyDeclaration>();
var field = RemoveBackingStoreAction.GetBackingField(context);
if (field == null)
{
yield break;
}
var resolvedType = ReflectionHelper.ParseReflectionName("System.EventHandler").Resolve(context.Compilation);
if (resolvedType == null)
{
yield break;
}
var type = (TypeDeclaration)property.Parent;
yield return(new CodeAction(context.TranslateString("Create changed event"), script => {
var eventDeclaration = CreateChangedEventDeclaration(context, property);
var methodDeclaration = CreateEventInvocatorAction.CreateEventInvocator(context, type, eventDeclaration, eventDeclaration.Variables.First(), resolvedType.GetDelegateInvokeMethod(), false);
var stmt = new ExpressionStatement(new InvocationExpression(
new IdentifierExpression(methodDeclaration.Name),
new MemberReferenceExpression(new TypeReferenceExpression(context.CreateShortType("System", "EventArgs")), "Empty")
));
var task = script.InsertWithCursor(
context.TranslateString("Create event invocator"),
Script.InsertPosition.After,
new AstNode[] { eventDeclaration, methodDeclaration }
);
Action <Task> insertInvocation = delegate {
script.InsertBefore(property.Setter.Body.RBraceToken, stmt);
script.FormatText(stmt);
};
if (task.IsCompleted)
{
insertInvocation(null);
}
else
{
task.ContinueWith(insertInvocation, TaskScheduler.FromCurrentSynchronizationContext());
}
}, property.NameToken));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var type = context.GetNode <AstType>();
if (type == null || type.Role != Roles.BaseType)
{
yield break;
}
var state = context.GetResolverStateBefore(type);
if (state.CurrentTypeDefinition == null)
{
yield break;
}
var resolveResult = context.Resolve(type);
if (resolveResult.Type.Kind != TypeKind.Class || resolveResult.Type.GetDefinition() == null || !resolveResult.Type.GetDefinition().IsAbstract)
{
yield break;
}
var toImplement = CollectMembersToImplement(state.CurrentTypeDefinition, resolveResult.Type);
if (toImplement.Count == 0)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Implement abstract members"), script =>
{
script.InsertWithCursor(
context.TranslateString("Implement abstract members"),
state.CurrentTypeDefinition,
ImplementInterfaceAction.GenerateImplementation(context, toImplement.Select(m => Tuple.Create(m, false))).Select(entity => {
var decl = entity as EntityDeclaration;
if (decl != null)
{
decl.Modifiers |= Modifiers.Override;
}
return entity;
})
);
}));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var initializer = context.GetNode <VariableInitializer>();
if (initializer == null || !initializer.NameToken.Contains(context.Location.Line, context.Location.Column))
{
yield break;
}
var type = initializer.Parent.Parent as TypeDeclaration;
if (type == null)
{
yield break;
}
foreach (var member in type.Members)
{
if (member is PropertyDeclaration && ContainsGetter((PropertyDeclaration)member, initializer))
{
yield break;
}
}
var field = initializer.Parent as FieldDeclaration;
if (field == null || field.HasModifier(Modifiers.Readonly) || field.HasModifier(Modifiers.Const))
{
yield break;
}
var resolveResult = context.Resolve(initializer) as MemberResolveResult;
if (resolveResult == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create property"), script =>
{
var fieldName = context.GetNameProposal(initializer.Name, true);
if (initializer.Name == context.GetNameProposal(initializer.Name, false))
{
script.Rename(resolveResult.Member, fieldName);
}
script.InsertWithCursor(
context.TranslateString("Create property"),
Script.InsertPosition.After, GeneratePropertyDeclaration(context, field, fieldName));
}));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
Expression node = context.GetNode <IdentifierExpression>();
if (node == null)
{
var mr = context.GetNode <MemberReferenceExpression>();
if (mr == null || !mr.MemberNameToken.IsInside(context.Location))
{
yield break;
}
node = mr;
}
if (node == null)
{
yield break;
}
var rr = context.Resolve(node) as MethodGroupResolveResult;
if (rr == null || rr.IsError)
{
yield break;
}
var type = TypeGuessing.GetValidTypes(context.Resolver, node).FirstOrDefault(t => t.Kind == TypeKind.Delegate);
if (type == null)
{
yield break;
}
var invocationMethod = type.GetDelegateInvokeMethod();
if (invocationMethod == null)
{
yield break;
}
yield return(new CodeAction(
context.TranslateString("Convert to anonymous method"),
script => {
var expr = new InvocationExpression(node.Clone(), invocationMethod.Parameters.Select(p => new IdentifierExpression(context.GetNameProposal(p.Name))));
var stmt = invocationMethod.ReturnType.IsKnownType(KnownTypeCode.Void) ? (Statement)expr : new ReturnStatement(expr);
var anonymousMethod = new AnonymousMethodExpression {
Body = new BlockStatement {
stmt
}
};
foreach (var p in invocationMethod.Parameters)
{
var decl = new ParameterDeclaration(context.CreateShortType(p.Type), context.GetNameProposal(p.Name));
anonymousMethod.Parameters.Add(decl);
}
script.Replace(node, anonymousMethod);
},
node
));
}
protected override CodeAction GetAction(RefactoringContext context, InvocationExpression node)
{
var mRef = node.Target as MemberReferenceExpression;
if (mRef == null)
{
return(null);
}
var rr = context.Resolve(node) as CSharpInvocationResolveResult;
if (rr == null || rr.IsError)
{
return(null);
}
if (rr.Member.Name != "HasFlag" || rr.Member.DeclaringType.GetDefinition().KnownTypeCode != ICSharpCode.NRefactory.TypeSystem.KnownTypeCode.Enum)
{
return(null);
}
var arg = node.Arguments.First().Clone();
if (!arg.DescendantsAndSelf.All(x => !(x is BinaryOperatorExpression) || ((BinaryOperatorExpression)x).Operator == BinaryOperatorType.BitwiseOr))
{
return(null);
}
arg = ConvertBitwiseFlagComparisonToHasFlagsAction.MakeFlatExpression(arg, BinaryOperatorType.BitwiseAnd);
if (arg is BinaryOperatorExpression)
{
arg = new ParenthesizedExpression(arg);
}
return(new CodeAction(
context.TranslateString("Replace with bitwise flag comparison"),
script => {
var uOp = node.Parent as UnaryOperatorExpression;
if (uOp != null && uOp.Operator == UnaryOperatorType.Not)
{
script.Replace(uOp,
new BinaryOperatorExpression(
new ParenthesizedExpression(new BinaryOperatorExpression(mRef.Target.Clone(), BinaryOperatorType.BitwiseAnd, arg)),
BinaryOperatorType.Equality,
new PrimitiveExpression(0)
)
);
}
else
{
script.Replace(node,
new BinaryOperatorExpression(
new ParenthesizedExpression(new BinaryOperatorExpression(mRef.Target.Clone(), BinaryOperatorType.BitwiseAnd, arg)),
BinaryOperatorType.InEquality,
new PrimitiveExpression(0)
)
);
}
},
node
));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var foreachStatement = GetForeachStatement(context);
if (foreachStatement == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Convert 'foreach' loop to 'for'"), script =>
{
var result = context.Resolve(foreachStatement.InExpression);
var countProperty = GetCountProperty(result.Type);
// TODO: use another variable name if 'i' is already in use
var initializer = new VariableDeclarationStatement(new PrimitiveType("int"), "i", new PrimitiveExpression(0));
var id1 = new IdentifierExpression("i");
var id2 = id1.Clone();
var id3 = id1.Clone();
var variableDeclarationStatement = new VariableDeclarationStatement(
foreachStatement.VariableType.Clone(),
foreachStatement.VariableName,
new IndexerExpression(foreachStatement.InExpression.Clone(), id3)
);
var forStatement = new ForStatement()
{
Initializers = { initializer },
Condition = new BinaryOperatorExpression(id1, BinaryOperatorType.LessThan, new MemberReferenceExpression(foreachStatement.InExpression.Clone(), countProperty)),
Iterators = { new ExpressionStatement(new UnaryOperatorExpression(UnaryOperatorType.PostIncrement, id2)) },
EmbeddedStatement = new BlockStatement
{
variableDeclarationStatement
}
};
if (foreachStatement.EmbeddedStatement is BlockStatement)
{
variableDeclarationStatement.Remove();
var oldBlock = (BlockStatement)foreachStatement.EmbeddedStatement.Clone();
if (oldBlock.Statements.Any())
{
oldBlock.Statements.InsertBefore(oldBlock.Statements.First(), variableDeclarationStatement);
}
else
{
oldBlock.Statements.Add(variableDeclarationStatement);
}
forStatement.EmbeddedStatement = oldBlock;
}
else
{
forStatement.EmbeddedStatement.AddChild(foreachStatement.EmbeddedStatement.Clone(), BlockStatement.StatementRole);
}
script.Replace(foreachStatement, forStatement);
script.Link(initializer.Variables.First().NameToken, id1, id2, id3);
}));
}
protected override CodeAction GetAction(RefactoringContext context, BinaryOperatorExpression node)
{
if (!node.OperatorToken.IsInside(context.Location))
{
return(null);
}
if (node.Operator == BinaryOperatorType.Add ||
node.Operator == BinaryOperatorType.BitwiseAnd ||
node.Operator == BinaryOperatorType.BitwiseOr ||
node.Operator == BinaryOperatorType.Divide ||
node.Operator == BinaryOperatorType.ExclusiveOr ||
node.Operator == BinaryOperatorType.Modulus ||
node.Operator == BinaryOperatorType.Multiply ||
node.Operator == BinaryOperatorType.NullCoalescing ||
node.Operator == BinaryOperatorType.ShiftLeft ||
node.Operator == BinaryOperatorType.ShiftRight ||
node.Operator == BinaryOperatorType.Subtract)
{
return(null);
}
var negativeExpression = CSharpUtil.InvertCondition(node);
if (node.Parent is ParenthesizedExpression && node.Parent.Parent is UnaryOperatorExpression)
{
var unaryOperatorExpression = node.Parent.Parent as UnaryOperatorExpression;
if (unaryOperatorExpression.Operator == UnaryOperatorType.Not)
{
return(new CodeAction(
string.Format(context.TranslateString("Invert '{0}'"), unaryOperatorExpression),
script => {
script.Replace(unaryOperatorExpression, negativeExpression);
}, node.OperatorToken
));
}
}
var newExpression = new UnaryOperatorExpression(UnaryOperatorType.Not, new ParenthesizedExpression(negativeExpression));
return(new CodeAction(
string.Format(context.TranslateString("Invert '{0}'"), node),
script => {
script.Replace(node, newExpression);
}, node.OperatorToken
));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode <PropertyDeclaration>();
if (property == null || !property.NameToken.Contains(context.Location))
{
yield break;
}
if (!(!property.Getter.IsNull && !property.Setter.IsNull && // automatic properties always need getter & setter
property.Getter.Body.IsNull &&
property.Setter.Body.IsNull))
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create backing store"), script => {
string backingStoreName = context.GetNameProposal(property.Name);
// create field
var backingStore = new FieldDeclaration();
if (property.Modifiers.HasFlag(Modifiers.Static))
{
backingStore.Modifiers |= Modifiers.Static;
}
backingStore.ReturnType = property.ReturnType.Clone();
var initializer = new VariableInitializer(backingStoreName);
backingStore.Variables.Add(initializer);
// create new property & implement the get/set bodies
var newProperty = (PropertyDeclaration)property.Clone();
Expression id1;
if (backingStoreName == "value")
{
id1 = new ThisReferenceExpression().Member("value");
}
else
{
id1 = new IdentifierExpression(backingStoreName);
}
Expression id2 = id1.Clone();
newProperty.Getter.Body = new BlockStatement()
{
new ReturnStatement(id1)
};
newProperty.Setter.Body = new BlockStatement()
{
new AssignmentExpression(id2, AssignmentOperatorType.Assign, new IdentifierExpression("value"))
};
script.Replace(property, newProperty);
script.InsertBefore(property, backingStore);
script.Link(initializer, id1, id2);
}, property.NameToken));
}
CodeAction MakeAction(RefactoringContext context, AstNode oldNode, AstNode replacementNode, IEnumerable <AstNode> toRemove)
{
return(new CodeAction(context.TranslateString("Convert to initializer"), script => {
foreach (var statement in toRemove)
{
script.Remove(statement);
}
script.Replace(oldNode, replacementNode);
}, oldNode));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
Expression node = context.GetNode <IdentifierExpression>();
if (node == null)
{
var mr = context.GetNode <MemberReferenceExpression>();
if (mr == null || !mr.MemberNameToken.IsInside(context.Location))
{
yield break;
}
node = mr;
}
if (node == null)
{
yield break;
}
var rr = context.Resolve(node) as MethodGroupResolveResult;
if (rr == null || rr.IsError)
{
yield break;
}
var type = TypeGuessing.GetValidTypes(context.Resolver, node).FirstOrDefault(t => t.Kind == TypeKind.Delegate);
if (type == null)
{
yield break;
}
var invocationMethod = type.GetDelegateInvokeMethod();
if (invocationMethod == null)
{
yield break;
}
yield return(new CodeAction(
context.TranslateString("Convert to lambda expression"),
script => {
var invocation = new InvocationExpression(node.Clone(), invocationMethod.Parameters.Select(p => new IdentifierExpression(context.GetNameProposal(p.Name))));
var lambda = new LambdaExpression {
Body = invocation
};
lambda.Parameters.AddRange(
invocation.Arguments
.Cast <IdentifierExpression>()
.Select(p => new ParameterDeclaration {
Name = p.Identifier
})
);
script.Replace(node, lambda);
},
node
));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var identifier = context.GetNode <IdentifierExpression>();
if (identifier == null)
{
yield break;
}
if (CreateFieldAction.IsInvocationTarget(identifier))
{
yield break;
}
var statement = context.GetNode <Statement>();
if (statement == null)
{
yield break;
}
if (!(context.Resolve(identifier).IsError))
{
yield break;
}
var guessedType = TypeGuessing.GuessAstType(context, identifier);
if (guessedType == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create local variable"), script => {
var initializer = new VariableInitializer(null, identifier.Identifier);
var decl = new VariableDeclarationStatement()
{
Type = guessedType,
Variables = { initializer }
};
if (identifier.Parent is AssignmentExpression && ((AssignmentExpression)identifier.Parent).Left == identifier)
{
initializer.Initializer = ((AssignmentExpression)identifier.Parent).Right.Clone();
if (!context.UseExplicitTypes)
{
decl.Type = new SimpleType("var");
}
script.Replace(statement, decl);
}
else
{
script.InsertBefore(statement, decl);
}
}, identifier)
{
Severity = ICSharpCode.NRefactory.Refactoring.Severity.Error
});
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var type = context.GetNode <AstType>();
if (type == null || type.Role != Roles.BaseType)
{
yield break;
}
var state = context.GetResolverStateBefore(type);
if (state.CurrentTypeDefinition == null)
{
yield break;
}
var resolveResult = context.Resolve(type);
if (resolveResult.Type.Kind != TypeKind.Interface)
{
yield break;
}
var toImplement = ImplementInterfaceAction.CollectMembersToImplement(
state.CurrentTypeDefinition,
resolveResult.Type,
false
);
if (toImplement.Count == 0)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Implement interface explicit"), script =>
{
script.InsertWithCursor(
context.TranslateString("Implement Interface"),
state.CurrentTypeDefinition,
ImplementInterfaceAction.GenerateImplementation(context, toImplement.Select(t => Tuple.Create(t.Item1, true)))
);
}));
}
protected override CodeAction GetAction(RefactoringContext context, MethodDeclaration node)
{
if (!(node.PrivateImplementationType.IsNull))
{
return(null);
}
if (!node.NameToken.Contains(context.Location))
{
return(null);
}
var method = (IMethod)((MemberResolveResult)context.Resolve(node)).Member;
if (method.Documentation != null)
{
return(null);
}
IList <IMember> interfaceMethods = method.ImplementedInterfaceMembers;
if (interfaceMethods.Count != 1 || method.DeclaringType.Kind == TypeKind.Interface)
{
return(null);
}
var interfaceMethod = interfaceMethods.SingleOrDefault();
if (interfaceMethod == null)
{
return(null);
}
if (interfaceMethod.Documentation == null)
{
return(null);
}
string comments = interfaceMethod.Documentation.ToString();
if (comments == "")
{
return(null);
}
string[] lines = comments.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
return(new CodeAction(context.TranslateString("Copy comments from interface"), script =>
{
foreach (string co in lines)
{
script.InsertBefore(node, new Comment(co, CommentType.Documentation));
}
}, node));
}
CodeAction GetAction(RefactoringContext context, AstNode node, MethodDeclaration method)
{
return(new CodeAction(context.TranslateString("Extract anonymous method"),
script =>
{
var identifier = new IdentifierExpression("Method");
script.Replace(node, identifier);
script.InsertBefore(node.GetParent <EntityDeclaration> (), method);
script.Link(method.NameToken, identifier);
}, method.NameToken));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var switchStatement = GetSwitchStatement(context);
if (switchStatement == null)
{
yield break;
}
var result = context.Resolve(switchStatement.Expression);
if (result.Type.Kind != TypeKind.Enum)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create switch labels"), script =>
{
var type = result.Type;
var newSwitch = (SwitchStatement)switchStatement.Clone();
var target = new TypeReferenceExpression(context.CreateShortType(result.Type));
foreach (var field in type.GetFields())
{
if (field.IsSynthetic || !field.IsConst)
{
continue;
}
newSwitch.SwitchSections.Add(new SwitchSection()
{
CaseLabels =
{
new CaseLabel(new MemberReferenceExpression(target.Clone(), field.Name))
},
Statements =
{
new BreakStatement()
}
});
}
newSwitch.SwitchSections.Add(new SwitchSection()
{
CaseLabels =
{
new CaseLabel()
},
Statements =
{
new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "ArgumentOutOfRangeException")))
}
});
script.Replace(switchStatement, newSwitch);
}));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var expr = GetEmptyString(context);
if (expr == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Use string.Empty"), script => {
script.Replace(expr, new PrimitiveType("string").Member("Empty"));
}, expr));
}
CodeAction CreateForConditionalExpression(RefactoringContext ctx, ReturnStatement node, ConditionalExpression conditionalExpression)
{
return(new CodeAction(
ctx.TranslateString("Replace with 'if' statement"),
script => {
var ifStatement = new IfElseStatement(conditionalExpression.Condition.Clone(), new ReturnStatement(conditionalExpression.TrueExpression.Clone()));
script.Replace(node, ifStatement);
script.InsertAfter(ifStatement, new ReturnStatement(conditionalExpression.FalseExpression.Clone()));
},
node
));
}
CodeAction CreateForNullCoalesingExpression(RefactoringContext ctx, ReturnStatement node, BinaryOperatorExpression bOp)
{
return(new CodeAction(
ctx.TranslateString("Replace with 'if' statement"),
script => {
var ifStatement = new IfElseStatement(new BinaryOperatorExpression(bOp.Left.Clone(), BinaryOperatorType.InEquality, new NullReferenceExpression()), new ReturnStatement(bOp.Left.Clone()));
script.Replace(node, ifStatement);
script.InsertAfter(ifStatement, new ReturnStatement(bOp.Right.Clone()));
},
node
));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var expr = GetEmptyString(context);
if (expr == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Use string.Empty"), script => {
script.Replace(expr, new MemberReferenceExpression(new TypeReferenceExpression(new PrimitiveType("string")), "Empty"));
}));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var ifStatement = GetIfElseStatement(context);
if (ifStatement == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Simplify if in loops"), script => {
GenerateNewScript(script, ifStatement);
}, ifStatement));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var property = context.GetNode <PropertyDeclaration>();
if (property == null || !property.NameToken.Contains(context.Location))
{
yield break;
}
var field = RemoveBackingStoreAction.GetBackingField(context, property);
if (field == null)
{
yield break;
}
var resolvedType = ReflectionHelper.ParseReflectionName("System.EventHandler").Resolve(context.Compilation);
if (resolvedType == null)
{
yield break;
}
var type = (TypeDeclaration)property.Parent;
yield return(new CodeAction(context.TranslateString("Create changed event"), script => {
var eventDeclaration = CreateChangedEventDeclaration(context, property);
var methodDeclaration = CreateEventInvocatorAction.CreateEventInvocator(context, type, eventDeclaration, eventDeclaration.Variables.First(), resolvedType.GetDelegateInvokeMethod(), false);
var stmt = new ExpressionStatement(new InvocationExpression(
new IdentifierExpression(methodDeclaration.Name),
context.CreateShortType("System", "EventArgs").Member("Empty")
));
script.InsertWithCursor(
context.TranslateString("Create event invocator"),
Script.InsertPosition.After,
new AstNode[] { eventDeclaration, methodDeclaration }
).ContinueScript(delegate {
script.InsertBefore(property.Setter.Body.RBraceToken, stmt);
script.FormatText(stmt);
});
}, property.NameToken));
}