public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var createExpression = context.GetNode <Expression>() as 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
);
}, createExpression));
}
static TypeDeclaration CreateClassFromObjectCreation(RefactoringContext context, ObjectCreateExpression createExpression)
{
TypeDeclaration result;
string className = createExpression.Type.GetText();
if (!createExpression.Arguments.Any())
{
result = new TypeDeclaration {
Name = className
};
}
else
{
var decl = new ConstructorDeclaration {
Name = className,
Modifiers = Modifiers.Public,
Body = new BlockStatement {
new ThrowStatement(new ObjectCreateExpression(context.CreateShortType("System", "NotImplementedException")))
}
};
result = new TypeDeclaration {
Name = className,
Members =
{
decl
}
};
decl.Parameters.AddRange(CreateMethodDeclarationAction.GenerateParameters(context, createExpression.Arguments));
}
var guessedType = CreateFieldAction.GuessType(context, createExpression);
if (guessedType.Kind == TypeKind.Interface || guessedType.Kind == TypeKind.Class && guessedType.GetDefinition().IsAbstract)
{
result.BaseTypes.Add(context.CreateShortType(guessedType));
AddImplementation(context, result, guessedType);
}
return(result);
}
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)
{
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 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);
}));
}
}
