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));
}
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);
}
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"))));
}
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 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 = CreateFieldAction.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(), decl);
return;
}
script.InsertWithCursor(context.TranslateString("Create indexer"), Script.InsertPosition.Before, decl);
}));
}
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 IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
//TODO: implement variable assignment & ctor param
var varInit = context.GetNode <VariableInitializer>();
if (varInit != null)
{
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.IsMatch(varType))
{
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);
}, varInit));
}
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));
}
}
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 || resolveResult.Type.Kind == TypeKind.Null ? new PrimitiveType("object") : context.CreateShortType(resolveResult.Type);
yield return(new ParameterDeclaration(type, name)
{
ParameterModifier = direction
});
}
}
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);
}
}));
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());
}));
}
}
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 pexpr = context.GetNode <PrimitiveExpression>();
if (pexpr == null)
{
yield break;
}
var statement = context.GetNode <Statement>();
if (statement == null)
{
yield break;
}
var visitor = new DeclareLocalVariableAction.SearchNodeVisitior(pexpr);
var node = context.GetNode <BlockStatement>();
if (node != null)
{
node.AcceptVisitor(visitor);
}
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"), Script.InsertPosition.Before, decl);
}));
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());
}));
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);
}));
}
}
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);
}
static void AddImplementation(RefactoringContext context, TypeDeclaration result, 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);
}
}
