IEnumerable <CodeAction> GetActionsFromIdentifier(RefactoringContext context, IdentifierExpression identifier)
{
if (!(context.Resolve(identifier).IsError))
{
yield break;
}
var methodName = identifier.Identifier;
var guessedType = CreateFieldAction.GuessType(context, identifier);
if (guessedType.Kind != TypeKind.Delegate)
{
yield break;
}
var invocationMethod = guessedType.GetDelegateInvokeMethod();
if (invocationMethod == null)
{
yield break;
}
var state = context.GetResolverStateBefore(identifier);
if (state.CurrentMember == null || state.CurrentTypeDefinition == null)
{
yield break;
}
bool isStatic = state.CurrentMember.IsStatic || state.CurrentTypeDefinition.IsStatic;
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null && !service.IsValidName(methodName, AffectedEntity.Method, Modifiers.Private, isStatic))
{
yield break;
}
yield return(CreateAction(
context,
methodName,
context.CreateShortType(invocationMethod.ReturnType),
invocationMethod.Parameters.Select(parameter => new ParameterDeclaration(context.CreateShortType(parameter.Type), parameter.Name)
{
ParameterModifier = GetModifiers(parameter)
}),
false,
isStatic,
null));
}
IEnumerable <ParameterDeclaration> GetParameters(IList <IParameter> parameters, RefactoringContext context)
{
foreach (var parameter in parameters)
{
var type = context.CreateShortType(parameter.Type);
var name = parameter.Name;
ParameterModifier modifier = ParameterModifier.None;
if (parameter.IsRef)
{
modifier |= ParameterModifier.Ref;
}
if (parameter.IsOut)
{
modifier |= ParameterModifier.Out;
}
yield return(new ParameterDeclaration(type, name, modifier));
}
}
static VariableInitializer GetVariableDeclarationStatement(RefactoringContext context, out AstType resolvedType, CancellationToken cancellationToken = default(CancellationToken))
{
var result = context.GetNode <VariableInitializer> ();
if (result != null && !result.Initializer.IsNull && context.Location <= result.Initializer.StartLocation)
{
var type = context.Resolve(result).Type;
if (type.Equals(SpecialType.NullType) || type.Equals(SpecialType.UnknownType))
{
resolvedType = new PrimitiveType("object");
}
else
{
resolvedType = context.CreateShortType(type);
}
return(result);
}
resolvedType = null;
return(null);
}
static IEnumerable <ParameterDeclaration> ConvertParameters(RefactoringContext context, IList <IParameter> parameters)
{
foreach (var param in parameters)
{
ParameterModifier mod = ParameterModifier.None;
if (param.IsOut)
{
mod = ParameterModifier.Out;
}
else if (param.IsRef)
{
mod = ParameterModifier.Ref;
}
else if (param.IsParams)
{
mod = ParameterModifier.Params;
}
yield return(new ParameterDeclaration(context.CreateShortType(param.Type), param.Name, mod));
}
}
static VariableDeclarationStatement GetVariableDeclarationStatement(RefactoringContext context, out AstType resolvedType, CancellationToken cancellationToken = default(CancellationToken))
{
var result = context.GetNode <VariableDeclarationStatement> ();
if (result != null && result.Variables.Count == 1 && !result.Variables.First().Initializer.IsNull&& result.Variables.First().NameToken.Contains(context.Location.Line, context.Location.Column))
{
var type = context.Resolve(result.Variables.First().Initializer).Type;
if (type.Equals(SpecialType.NullType) || type.Equals(SpecialType.UnknownType))
{
resolvedType = new PrimitiveType("object");
}
else
{
resolvedType = context.CreateShortType(type);
}
return(result);
}
resolvedType = null;
return(null);
}
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));
}
static Statement BuildAccessorStatement(RefactoringContext context, PropertyDeclaration pdecl)
{
if (pdecl.Setter.IsNull && !pdecl.Getter.IsNull)
{
var field = RemoveBackingStoreAction.ScanGetter(context, pdecl);
if (field != null)
{
return(new ExpressionStatement(new AssignmentExpression(new IdentifierExpression(field.Name), AssignmentOperatorType.Assign, new IdentifierExpression("value"))));
}
}
if (!pdecl.Setter.IsNull && pdecl.Getter.IsNull)
{
var field = RemoveBackingStoreAction.ScanSetter(context, pdecl);
if (field != null)
{
return(new ReturnStatement(new IdentifierExpression(field.Name)));
}
}
return(new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException"))));
}
protected override CodeAction GetAction(RefactoringContext context, MethodDeclaration node)
{
if (!node.PrivateImplementationType.IsNull)
{
return(null);
}
if (!node.NameToken.Contains(context.Location))
{
return(null);
}
var memberResolveResult = context.Resolve(node) as MemberResolveResult;
if (memberResolveResult == null)
{
return(null);
}
var method = memberResolveResult.Member as IMethod;
if (method == null || method.ImplementedInterfaceMembers.Count != 1 || method.DeclaringType.Kind == TypeKind.Interface)
{
return(null);
}
return(new CodeAction(context.TranslateString("Convert implict to explicit implementation"),
script =>
{
var explicitImpl = (MethodDeclaration)node.Clone();
// remove visibility modifier
explicitImpl.Modifiers &= ~Modifiers.VisibilityMask;
var implementedInterface = method.ImplementedInterfaceMembers [0].DeclaringType;
explicitImpl.PrivateImplementationType = context.CreateShortType(implementedInterface);
script.Replace(node, explicitImpl);
},
node.NameToken
));
}
static CodeAction CreateAction(RefactoringContext context, string methodName, AstType returnType, IEnumerable <ParameterDeclaration> parameters, bool createInOtherType, bool isStatic, ResolveResult targetResolveResult)
{
return(new CodeAction(context.TranslateString("Create method"), script => {
var decl = new MethodDeclaration()
{
ReturnType = returnType,
Name = methodName,
Body = new BlockStatement()
{
new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException")))
}
};
decl.Parameters.AddRange(parameters);
if (isStatic)
{
decl.Modifiers |= Modifiers.Static;
}
if (createInOtherType)
{
if (targetResolveResult.Type.Kind == TypeKind.Interface)
{
decl.Body = null;
decl.Modifiers = Modifiers.None;
}
else
{
decl.Modifiers |= Modifiers.Public;
}
script.InsertWithCursor(context.TranslateString("Create method"), targetResolveResult.Type.GetDefinition(), decl);
return;
}
script.InsertWithCursor(context.TranslateString("Create method"), Script.InsertPosition.Before, decl);
}));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var createExpression = context.GetNode <ObjectCreateExpression>();
if (createExpression == null)
{
yield break;
}
var resolveResult = context.Resolve(createExpression) as CSharpInvocationResolveResult;
if (resolveResult == null || !resolveResult.IsError || resolveResult.Member.DeclaringTypeDefinition == null || resolveResult.Member.DeclaringTypeDefinition.IsSealed || resolveResult.Member.DeclaringTypeDefinition.Region.IsEmpty)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create constructor"), script =>
{
var decl = new ConstructorDeclaration()
{
Name = resolveResult.Member.DeclaringTypeDefinition.Name,
Modifiers = Modifiers.Public,
Body = new BlockStatement()
{
new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException")))
}
};
decl.Parameters.AddRange(CreateMethodDeclarationAction.GenerateParameters(context, createExpression.Arguments));
script.InsertWithCursor(
context.TranslateString("Create constructor"),
resolveResult.Member.DeclaringTypeDefinition,
decl
);
}));
}
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));
}
public static MethodDeclaration CreateEventInvocator(RefactoringContext context, TypeDeclaration declaringType, EventDeclaration eventDeclaration, VariableInitializer initializer, IMethod invokeMethod, bool useExplictType)
{
bool hasSenderParam = false;
IEnumerable <IParameter> pars = invokeMethod.Parameters;
if (invokeMethod.Parameters.Any())
{
var first = invokeMethod.Parameters [0];
if (first.Name == "sender" /*&& first.Type == "System.Object"*/)
{
hasSenderParam = true;
pars = invokeMethod.Parameters.Skip(1);
}
}
const string handlerName = "handler";
var arguments = new List <Expression>();
if (hasSenderParam)
{
arguments.Add(eventDeclaration.HasModifier(Modifiers.Static) ? (Expression) new PrimitiveExpression(null) : new ThisReferenceExpression());
}
bool useThisMemberReference = false;
foreach (var par in pars)
{
arguments.Add(new IdentifierExpression(par.Name));
useThisMemberReference |= par.Name == initializer.Name;
}
var proposedHandlerName = GetNameProposal(initializer);
var modifiers = eventDeclaration.HasModifier(Modifiers.Static) ? Modifiers.Static : Modifiers.Protected | Modifiers.Virtual;
if (declaringType.HasModifier(Modifiers.Sealed))
{
modifiers = Modifiers.None;
}
var methodDeclaration = new MethodDeclaration {
Name = proposedHandlerName,
ReturnType = new PrimitiveType("void"),
Modifiers = modifiers,
Body = new BlockStatement {
new VariableDeclarationStatement(
useExplictType ? eventDeclaration.ReturnType.Clone() : new PrimitiveType("var"), handlerName,
useThisMemberReference ?
(Expression) new MemberReferenceExpression(new ThisReferenceExpression(), initializer.Name)
: new IdentifierExpression(initializer.Name)
),
new IfElseStatement {
Condition = new BinaryOperatorExpression(new IdentifierExpression(handlerName), BinaryOperatorType.InEquality, new PrimitiveExpression(null)),
TrueStatement = new ExpressionStatement(new InvocationExpression(new IdentifierExpression(handlerName), arguments))
}
}
};
foreach (var par in pars)
{
var typeName = context.CreateShortType(par.Type);
var decl = new ParameterDeclaration(typeName, par.Name);
methodDeclaration.Parameters.Add(decl);
}
return(methodDeclaration);
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var pexpr = context.GetNode <PrimitiveExpression>();
if (pexpr == null)
{
yield break;
}
var statement = context.GetNode <Statement>();
if (statement == null)
{
yield break;
}
var resolveResult = context.Resolve(pexpr);
yield return(new CodeAction(context.TranslateString("Create local constant"), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
{
name = service.CheckName(context, name, AffectedEntity.LocalConstant);
}
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new VariableDeclarationStatement()
{
Type = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
script.InsertBefore(statement, decl);
var variableUsage = new IdentifierExpression(name);
script.Replace(pexpr, variableUsage);
script.Link(initializer.NameToken, variableUsage);
}));
yield return(new CodeAction(context.TranslateString("Create constant field"), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
{
name = service.CheckName(context, name, AffectedEntity.ConstantField);
}
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new FieldDeclaration()
{
ReturnType = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
var variableUsage = new IdentifierExpression(name);
script.Replace(pexpr, variableUsage);
// script.Link(initializer.NameToken, variableUsage);
script.InsertWithCursor(context.TranslateString("Create constant"), decl, Script.InsertPosition.Before);
}));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var switchStatement = context.GetNode <SwitchStatement> ();
if (switchStatement == null || !switchStatement.SwitchToken.Contains(context.Location))
{
yield break;
}
var result = context.Resolve(switchStatement.Expression);
if (result.Type.Kind != TypeKind.Enum)
{
yield break;
}
if (switchStatement.SwitchSections.Count == 0)
{
yield return(new CodeAction(context.TranslateString("Create switch labels"), script => {
var type = result.Type;
var newSwitch = (SwitchStatement)switchStatement.Clone();
var target = 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);
}, switchStatement));
}
else
{
var missingFields = new List <IField>();
foreach (var field in result.Type.GetFields())
{
if (field.IsSynthetic || !field.IsConst)
{
continue;
}
if (!IsHandled(context, switchStatement, field))
{
missingFields.Add(field);
}
}
if (missingFields.Count == 0)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create missing switch labels"), script => {
var type = result.Type;
//var newSwitch = (SwitchStatement)switchStatement.Clone();
var insertNode = (AstNode)switchStatement.SwitchSections.LastOrDefault(s => !s.CaseLabels.Any(label => label.Expression.IsNull)) ?? switchStatement.LBraceToken;
var target = context.CreateShortType(result.Type);
foreach (var field in missingFields)
{
script.InsertAfter(insertNode, new SwitchSection()
{
CaseLabels =
{
new CaseLabel(new MemberReferenceExpression(target.Clone(), field.Name))
},
Statements =
{
new BreakStatement()
}
});
}
}, switchStatement));
}
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
if (!context.IsSomethingSelected)
{
yield break;
}
var selected = new List <AstNode>(context.GetSelectedNodes());
if (selected.Count != 1 || !(selected [0] is Expression))
{
yield break;
}
var expr = selected [0] as Expression;
var visitor = new SearchNodeVisitior(expr);
var node = context.GetNode <BlockStatement>();
if (node != null)
{
node.AcceptVisitor(visitor);
}
yield return(new CodeAction(context.TranslateString("Declare local variable"), script => {
var resolveResult = context.Resolve(expr);
var guessedType = resolveResult.Type;
if (resolveResult is MethodGroupResolveResult)
{
guessedType = GetDelegateType(context, ((MethodGroupResolveResult)resolveResult).Methods.First(), expr);
}
var name = CreateMethodDeclarationAction.CreateBaseName(expr, guessedType);
var type = context.UseExplicitTypes ? context.CreateShortType(guessedType) : new SimpleType("var");
var varDecl = new VariableDeclarationStatement(type, name, expr.Clone());
var replaceNode = visitor.Matches.First() as Expression;
if (replaceNode.Parent is ExpressionStatement)
{
script.Replace(replaceNode.Parent, varDecl);
script.Select(varDecl.Variables.First().NameToken);
}
else
{
var containing = replaceNode.Parent;
while (!(containing.Parent is BlockStatement))
{
containing = containing.Parent;
}
script.InsertBefore(containing, varDecl);
var identifierExpression = new IdentifierExpression(name);
script.Replace(replaceNode, identifierExpression);
script.Link(varDecl.Variables.First().NameToken, identifierExpression);
}
}, expr));
if (visitor.Matches.Count > 1)
{
yield return(new CodeAction(string.Format(context.TranslateString("Declare local variable (replace '{0}' occurrences)"), visitor.Matches.Count), script => {
var resolveResult = context.Resolve(expr);
var guessedType = resolveResult.Type;
if (resolveResult is MethodGroupResolveResult)
{
guessedType = GetDelegateType(context, ((MethodGroupResolveResult)resolveResult).Methods.First(), expr);
}
var linkedNodes = new List <AstNode>();
var name = CreateMethodDeclarationAction.CreateBaseName(expr, guessedType);
var type = context.UseExplicitTypes ? context.CreateShortType(guessedType) : new SimpleType("var");
var varDecl = new VariableDeclarationStatement(type, name, expr.Clone());
linkedNodes.Add(varDecl.Variables.First().NameToken);
var first = visitor.Matches [0];
if (first.Parent is ExpressionStatement)
{
script.Replace(first.Parent, varDecl);
}
else
{
var containing = first.Parent;
while (!(containing.Parent is BlockStatement))
{
containing = containing.Parent;
}
script.InsertBefore(containing, varDecl);
var identifierExpression = new IdentifierExpression(name);
linkedNodes.Add(identifierExpression);
script.Replace(first, identifierExpression);
}
for (int i = 1; i < visitor.Matches.Count; i++)
{
var identifierExpression = new IdentifierExpression(name);
linkedNodes.Add(identifierExpression);
script.Replace(visitor.Matches [i], identifierExpression);
}
script.Link(linkedNodes.ToArray());
}, expr));
}
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
//TODO: implement variable assignment & ctor param
var varInit = context.GetNode <VariableInitializer>();
if (varInit != null)
{
var selectedNode = varInit.GetNodeAt(context.Location);
if (selectedNode != varInit.NameToken)
{
yield break;
}
AstType type = varInit.GetPrevNode() as AstType;
if (type == null)
{
yield break;
}
if (varInit.Parent is FieldDeclaration)
{
yield break;
}
if (CannotExtractField(context, varInit))
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Assign to new field"), s => {
var name = varInit.Name;
AstType extractedType;
if (type.IsVar())
{
IType resolvedType = context.Resolve(varInit.Initializer).Type;
extractedType = context.CreateShortType(resolvedType);
}
else
{
extractedType = (AstType)type.Clone();
}
AstNode entityDeclarationNode = varInit.Parent;
while (!(entityDeclarationNode is EntityDeclaration) || (entityDeclarationNode is Accessor))
{
entityDeclarationNode = entityDeclarationNode.Parent;
}
var entity = (EntityDeclaration)entityDeclarationNode;
bool isStatic = entity.HasModifier(Modifiers.Static);
FieldDeclaration field = new FieldDeclaration()
{
Modifiers = isStatic ? Modifiers.Static : Modifiers.None,
ReturnType = extractedType,
Variables = { new VariableInitializer(name) }
};
AstNode nodeToRemove = RemoveDeclaration(varInit) ? varInit.Parent : type;
s.Remove(nodeToRemove, true);
s.InsertWithCursor(context.TranslateString("Insert new field"), Script.InsertPosition.Before, field);
s.FormatText(varInit.Parent);
}, selectedNode));
}
var idntf = context.GetNode <Identifier>();
if (idntf == null)
{
yield break;
}
var paramDec = idntf.Parent as ParameterDeclaration;
if (paramDec != null)
{
var ctor = paramDec.Parent as ConstructorDeclaration;
if (ctor == null)
{
yield break;
}
MemberReferenceExpression thisField = new MemberReferenceExpression(new ThisReferenceExpression(), idntf.Name, new AstType[] {});
var assign = new AssignmentExpression(thisField, AssignmentOperatorType.Assign, new IdentifierExpression(idntf.Name));
var statement = new ExpressionStatement(assign);
var type = (idntf.GetPrevNode() as AstType).Clone();
FieldDeclaration field = new FieldDeclaration()
{
ReturnType = type.Clone(),
Variables = { new VariableInitializer(idntf.Name) }
};
yield return(new CodeAction(context.TranslateString("Assign to new field"), s => {
s.InsertWithCursor(context.TranslateString("Insert new field"), Script.InsertPosition.Before, field);
s.AddTo(ctor.Body, statement);
}, paramDec.NameToken));
}
}
public void Run(RefactoringContext context)
{
VariableInitializer initializer;
var eventDeclaration = GetEventDeclaration(context, out initializer);
var type = context.Resolve(eventDeclaration.ReturnType).Type;
if (type == null)
{
return;
}
var invokeMethod = type.GetDelegateInvokeMethod();
if (invokeMethod == null)
{
return;
}
bool hasSenderParam = false;
IEnumerable <IParameter> pars = invokeMethod.Parameters;
if (invokeMethod.Parameters.Any())
{
var first = invokeMethod.Parameters [0];
if (first.Name == "sender" /*&& first.Type == "System.Object"*/)
{
hasSenderParam = true;
pars = invokeMethod.Parameters.Skip(1);
}
}
const string handlerName = "handler";
var arguments = new List <Expression> ();
if (hasSenderParam)
{
arguments.Add(new ThisReferenceExpression());
}
foreach (var par in pars)
{
arguments.Add(new IdentifierExpression(par.Name));
}
var methodDeclaration = new MethodDeclaration()
{
Name = "On" + initializer.Name,
ReturnType = new PrimitiveType("void"),
Modifiers = ICSharpCode.NRefactory.CSharp.Modifiers.Protected | ICSharpCode.NRefactory.CSharp.Modifiers.Virtual,
Body = new BlockStatement()
{
new VariableDeclarationStatement(context.CreateShortType(eventDeclaration.ReturnType), handlerName, new MemberReferenceExpression(new ThisReferenceExpression(), initializer.Name)),
new IfElseStatement()
{
Condition = new BinaryOperatorExpression(new IdentifierExpression(handlerName), BinaryOperatorType.InEquality, new PrimitiveExpression(null)),
TrueStatement = new ExpressionStatement(new InvocationExpression(new IdentifierExpression(handlerName), arguments))
}
}
};
foreach (var par in pars)
{
var typeName = context.CreateShortType(par.Type.Resolve(context.TypeResolveContext));
var decl = new ParameterDeclaration(typeName, par.Name);
methodDeclaration.Parameters.Add(decl);
}
using (var script = context.StartScript()) {
script.InsertWithCursor("Create event invocator", methodDeclaration, Script.InsertPosition.After);
}
}
static AstNode GenerateMethod(RefactoringContext context, IMethod method, bool explicitImplementation)
{
var result = new MethodDeclaration()
{
Name = method.Name,
ReturnType = context.CreateShortType(method.ReturnType),
Body = new BlockStatement()
{
new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException")))
}
};
if (!explicitImplementation)
{
result.Modifiers = Modifiers.Public;
}
else
{
result.PrivateImplementationType = context.CreateShortType(method.DeclaringType);
}
foreach (var typeParam in method.TypeParameters)
{
result.TypeParameters.Add(new TypeParameterDeclaration(typeParam.Name));
var constraint = new Constraint()
{
TypeParameter = new SimpleType(typeParam.Name)
};
if (typeParam.HasDefaultConstructorConstraint)
{
constraint.BaseTypes.Add(new PrimitiveType("new"));
}
else if (typeParam.HasReferenceTypeConstraint)
{
constraint.BaseTypes.Add(new PrimitiveType("class"));
}
else if (typeParam.HasValueTypeConstraint)
{
constraint.BaseTypes.Add(new PrimitiveType("struct"));
}
foreach (var type in typeParam.DirectBaseTypes)
{
if (type.FullName == "System.Object")
{
continue;
}
if (type.FullName == "System.ValueType")
{
continue;
}
constraint.BaseTypes.Add(context.CreateShortType(type));
}
if (constraint.BaseTypes.Count == 0)
{
continue;
}
result.Constraints.Add(constraint);
}
foreach (var p in method.Parameters)
{
ParameterModifier modifier;
if (p.IsOut)
{
modifier = ParameterModifier.Out;
}
else if (p.IsRef)
{
modifier = ParameterModifier.Ref;
}
else if (p.IsParams)
{
modifier = ParameterModifier.Params;
}
else
{
modifier = ParameterModifier.None;
}
result.Parameters.Add(new ParameterDeclaration(context.CreateShortType(p.Type), p.Name, modifier));
}
return(result);
}
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 override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var pexpr = context.GetNode <PrimitiveExpression>();
if (pexpr == null)
{
yield break;
}
var visitor = new DeclareLocalVariableAction.SearchNodeVisitior(pexpr);
if (pexpr.Parent is VariableInitializer)
{
var varDec = pexpr.Parent.Parent as VariableDeclarationStatement;
if (varDec != null && (varDec.Modifiers & Modifiers.Const) != 0)
{
yield break;
}
var fieldDecl = pexpr.Parent.Parent as FieldDeclaration;
if (fieldDecl != null && (fieldDecl.Modifiers & Modifiers.Const) != 0)
{
yield break;
}
}
var node = context.GetNode <BlockStatement>();
if (node != null)
{
node.AcceptVisitor(visitor);
}
var resolveResult = context.Resolve(pexpr);
var statement = context.GetNode <Statement>();
if (statement != null)
{
yield return(new CodeAction(context.TranslateString("Create local constant"), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
{
name = service.CheckName(context, name, AffectedEntity.LocalConstant);
}
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new VariableDeclarationStatement()
{
Type = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
script.InsertBefore(statement, decl);
var variableUsage = new IdentifierExpression(name);
script.Replace(pexpr, variableUsage);
script.Link(initializer.NameToken, variableUsage);
}, pexpr));
}
yield return(new CodeAction(context.TranslateString("Create constant field"), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
{
name = service.CheckName(context, name, AffectedEntity.ConstantField);
}
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new FieldDeclaration()
{
ReturnType = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
var variableUsage = new IdentifierExpression(name);
script.Replace(pexpr, variableUsage);
// script.Link(initializer.NameToken, variableUsage);
script.InsertWithCursor(context.TranslateString("Create constant"), Script.InsertPosition.Before, decl);
}, pexpr));
if (visitor.Matches.Count > 1)
{
yield return(new CodeAction(string.Format(context.TranslateString("Create local constant (replace '{0}' occurrences)"), visitor.Matches.Count), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
{
name = service.CheckName(context, name, AffectedEntity.LocalConstant);
}
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new VariableDeclarationStatement()
{
Type = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
script.InsertBefore(statement, decl);
var linkedNodes = new List <AstNode>();
linkedNodes.Add(initializer.NameToken);
for (int i = 0; i < visitor.Matches.Count; i++)
{
var identifierExpression = new IdentifierExpression(name);
linkedNodes.Add(identifierExpression);
script.Replace(visitor.Matches [i], identifierExpression);
}
script.Link(linkedNodes.ToArray());
}, pexpr));
yield return(new CodeAction(string.Format(context.TranslateString("Create constant field (replace '{0}' occurrences)"), visitor.Matches.Count), script => {
string name = CreateMethodDeclarationAction.CreateBaseName(pexpr, resolveResult.Type);
var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
if (service != null)
{
name = service.CheckName(context, name, AffectedEntity.ConstantField);
}
var initializer = new VariableInitializer(name, pexpr.Clone());
var decl = new FieldDeclaration()
{
ReturnType = context.CreateShortType(resolveResult.Type),
Modifiers = Modifiers.Const,
Variables = { initializer }
};
var linkedNodes = new List <AstNode>();
linkedNodes.Add(initializer.NameToken);
for (int i = 0; i < visitor.Matches.Count; i++)
{
var identifierExpression = new IdentifierExpression(name);
linkedNodes.Add(identifierExpression);
script.Replace(visitor.Matches [i], identifierExpression);
}
script.InsertWithCursor(context.TranslateString("Create constant"), Script.InsertPosition.Before, decl);
}, pexpr));
}
}
IEnumerable <CodeAction> GetActionsFromMemberReferenceExpression(RefactoringContext context, MemberReferenceExpression invocation)
{
if (!(context.Resolve(invocation).IsError))
{
yield break;
}
var methodName = invocation.MemberName;
var guessedType = CreateFieldAction.GuessType(context, invocation);
if (guessedType.Kind != TypeKind.Delegate)
{
yield break;
}
var invocationMethod = guessedType.GetDelegateInvokeMethod();
var state = context.GetResolverStateBefore(invocation);
if (state.CurrentTypeDefinition == null)
{
yield break;
}
ResolveResult targetResolveResult = context.Resolve(invocation.Target);
bool createInOtherType = !state.CurrentTypeDefinition.Equals(targetResolveResult.Type.GetDefinition());
bool isStatic;
if (createInOtherType)
{
if (targetResolveResult.Type.GetDefinition() == null || targetResolveResult.Type.GetDefinition().Region.IsEmpty)
{
yield break;
}
isStatic = targetResolveResult is TypeResolveResult;
if (isStatic && targetResolveResult.Type.Kind == TypeKind.Interface || targetResolveResult.Type.Kind == TypeKind.Enum)
{
yield break;
}
}
else
{
if (state.CurrentMember == null)
{
yield break;
}
isStatic = state.CurrentMember.IsStatic || state.CurrentTypeDefinition.IsStatic;
}
// var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
// if (service != null && !service.IsValidName(methodName, AffectedEntity.Method, Modifiers.Private, isStatic)) {
// yield break;
// }
yield return(CreateAction(
context,
methodName,
context.CreateShortType(invocationMethod.ReturnType),
invocationMethod.Parameters.Select(parameter => new ParameterDeclaration(context.CreateShortType(parameter.Type), parameter.Name)
{
ParameterModifier = GetModifiers(parameter)
}),
createInOtherType,
isStatic,
targetResolveResult));
}
public static IEnumerable <ParameterDeclaration> GenerateParameters(RefactoringContext context, IEnumerable <Expression> arguments)
{
var nameCounter = new Dictionary <string, int>();
foreach (var argument in arguments)
{
var direction = ParameterModifier.None;
AstNode node;
if (argument is DirectionExpression)
{
var de = (DirectionExpression)argument;
direction = de.FieldDirection == FieldDirection.Out ? ParameterModifier.Out : ParameterModifier.Ref;
node = de.Expression;
}
else
{
node = argument;
}
var resolveResult = context.Resolve(node);
string name = CreateBaseName(argument, resolveResult.Type);
if (!nameCounter.ContainsKey(name))
{
nameCounter [name] = 1;
}
else
{
nameCounter [name]++;
name += nameCounter [name].ToString();
}
var type = resolveResult.Type.Kind == TypeKind.Unknown ? new PrimitiveType("object") : context.CreateShortType(resolveResult.Type);
yield return(new ParameterDeclaration(type, name)
{
ParameterModifier = direction
});
}
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
VariableInitializer initializer;
var eventDeclaration = GetEventDeclaration(context, out initializer);
if (eventDeclaration == null)
{
yield break;
}
var type = (TypeDeclaration)eventDeclaration.Parent;
var proposedHandlerName = "On" + char.ToUpper(initializer.Name [0]) + initializer.Name.Substring(1);
if (type.Members.Any(m => m is MethodDeclaration && ((MethodDeclaration)m).Name == proposedHandlerName))
{
yield break;
}
var resolvedType = context.Resolve(eventDeclaration.ReturnType).Type;
if (resolvedType.Kind == TypeKind.Unknown)
{
yield break;
}
var invokeMethod = resolvedType.GetDelegateInvokeMethod();
if (invokeMethod == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create event invocator"), script => {
bool hasSenderParam = false;
IEnumerable <IParameter> pars = invokeMethod.Parameters;
if (invokeMethod.Parameters.Any())
{
var first = invokeMethod.Parameters [0];
if (first.Name == "sender" /*&& first.Type == "System.Object"*/)
{
hasSenderParam = true;
pars = invokeMethod.Parameters.Skip(1);
}
}
const string handlerName = "handler";
var arguments = new List <Expression>();
if (hasSenderParam)
{
arguments.Add(eventDeclaration.HasModifier(Modifiers.Static) ? (Expression) new PrimitiveExpression(null) : new ThisReferenceExpression());
}
bool useThisMemberReference = false;
foreach (var par in pars)
{
arguments.Add(new IdentifierExpression(par.Name));
useThisMemberReference |= par.Name == initializer.Name;
}
var methodDeclaration = new MethodDeclaration()
{
Name = proposedHandlerName,
ReturnType = new PrimitiveType("void"),
Modifiers = eventDeclaration.HasModifier(Modifiers.Static) ? Modifiers.Static : Modifiers.Protected | Modifiers.Virtual,
Body = new BlockStatement()
{
new VariableDeclarationStatement(
UseExplictType ? eventDeclaration.ReturnType.Clone() : new PrimitiveType("var"), handlerName,
useThisMemberReference ?
(Expression) new MemberReferenceExpression(new ThisReferenceExpression(), initializer.Name)
: new IdentifierExpression(initializer.Name)
),
new IfElseStatement()
{
Condition = new BinaryOperatorExpression(new IdentifierExpression(handlerName), BinaryOperatorType.InEquality, new PrimitiveExpression(null)),
TrueStatement = new ExpressionStatement(new InvocationExpression(new IdentifierExpression(handlerName), arguments))
}
}
};
foreach (var par in pars)
{
var typeName = context.CreateShortType(par.Type);
var decl = new ParameterDeclaration(typeName, par.Name);
methodDeclaration.Parameters.Add(decl);
}
script.InsertWithCursor(
context.TranslateString("Create event invocator"),
Script.InsertPosition.After,
methodDeclaration
);
}));
}
public override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var indexer = context.GetNode <IndexerExpression>();
if (indexer == null)
{
yield break;
}
if (!(context.Resolve(indexer).IsError))
{
yield break;
}
var state = context.GetResolverStateBefore(indexer);
if (state.CurrentTypeDefinition == null)
{
yield break;
}
var guessedType = TypeGuessing.GuessAstType(context, indexer);
bool createInOtherType = false;
ResolveResult targetResolveResult = null;
targetResolveResult = context.Resolve(indexer.Target);
createInOtherType = !state.CurrentTypeDefinition.Equals(targetResolveResult.Type.GetDefinition());
bool isStatic;
if (createInOtherType)
{
if (targetResolveResult.Type.GetDefinition() == null || targetResolveResult.Type.GetDefinition().Region.IsEmpty)
{
yield break;
}
isStatic = targetResolveResult is TypeResolveResult;
if (isStatic && targetResolveResult.Type.Kind == TypeKind.Interface || targetResolveResult.Type.Kind == TypeKind.Enum)
{
yield break;
}
}
else
{
isStatic = indexer.Target is IdentifierExpression && state.CurrentMember.IsStatic;
}
yield return(new CodeAction(context.TranslateString("Create indexer"), script => {
var decl = new IndexerDeclaration()
{
ReturnType = guessedType,
Getter = new Accessor()
{
Body = new BlockStatement()
{
new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException")))
}
},
Setter = new Accessor()
{
Body = new BlockStatement()
{
new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException")))
}
},
};
decl.Parameters.AddRange(CreateMethodDeclarationAction.GenerateParameters(context, indexer.Arguments));
if (isStatic)
{
decl.Modifiers |= Modifiers.Static;
}
if (createInOtherType)
{
if (targetResolveResult.Type.Kind == TypeKind.Interface)
{
decl.Getter.Body = null;
decl.Setter.Body = null;
decl.Modifiers = Modifiers.None;
}
else
{
decl.Modifiers |= Modifiers.Public;
}
script.InsertWithCursor(context.TranslateString("Create indexer"), targetResolveResult.Type.GetDefinition(), (s, c) => decl);
return;
}
script.InsertWithCursor(context.TranslateString("Create indexer"), Script.InsertPosition.Before, decl);
}, indexer)
{
Severity = ICSharpCode.NRefactory.Refactoring.Severity.Error
});
}
static void AddImplementation(RefactoringContext context, TypeDeclaration result, ICSharpCode.NRefactory.TypeSystem.IType guessedType)
{
foreach (var property in guessedType.GetProperties())
{
if (!property.IsAbstract)
{
continue;
}
if (property.IsIndexer)
{
var indexerDecl = new IndexerDeclaration()
{
ReturnType = context.CreateShortType(property.ReturnType),
Modifiers = GetModifiers(property),
Name = property.Name
};
indexerDecl.Parameters.AddRange(ConvertParameters(context, property.Parameters));
if (property.CanGet)
{
indexerDecl.Getter = new Accessor();
}
if (property.CanSet)
{
indexerDecl.Setter = new Accessor();
}
result.AddChild(indexerDecl, Roles.TypeMemberRole);
continue;
}
var propDecl = new PropertyDeclaration()
{
ReturnType = context.CreateShortType(property.ReturnType),
Modifiers = GetModifiers(property),
Name = property.Name
};
if (property.CanGet)
{
propDecl.Getter = new Accessor();
}
if (property.CanSet)
{
propDecl.Setter = new Accessor();
}
result.AddChild(propDecl, Roles.TypeMemberRole);
}
foreach (var method in guessedType.GetMethods())
{
if (!method.IsAbstract)
{
continue;
}
var decl = new MethodDeclaration()
{
ReturnType = context.CreateShortType(method.ReturnType),
Modifiers = GetModifiers(method),
Name = method.Name,
Body = new BlockStatement()
{
new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException")))
}
};
decl.Parameters.AddRange(ConvertParameters(context, method.Parameters));
result.AddChild(decl, Roles.TypeMemberRole);
}
foreach (var evt in guessedType.GetEvents())
{
if (!evt.IsAbstract)
{
continue;
}
var decl = new EventDeclaration()
{
ReturnType = context.CreateShortType(evt.ReturnType),
Modifiers = GetModifiers(evt),
Name = evt.Name
};
result.AddChild(decl, Roles.TypeMemberRole);
}
}
