static TypeDeclaration CreateClassFromType(RefactoringContext context, ClassType classType, SimpleType simpleType)
{
TypeDeclaration result;
string className = simpleType.Identifier;
if (simpleType.Parent is Attribute && classType == ClassType.Class)
{
if (!className.EndsWith("Attribute", System.StringComparison.Ordinal))
{
className += "Attribute";
}
}
result = new TypeDeclaration {
Name = className, ClassType = classType
};
var entity = simpleType.GetParent <EntityDeclaration>();
if (entity != null)
{
result.Modifiers |= entity.Modifiers & Modifiers.Public;
}
var guessedType = CreateFieldAction.GuessType(context, simpleType);
if (guessedType.Kind == TypeKind.TypeParameter)
{
ImplementConstraints(context, result, (ITypeParameter)guessedType);
}
return(result);
}
void AnalyzeExpression(AstNode expression, AstNode body, AstNodeCollection <ParameterDeclaration> parameters)
{
var invocation = AnalyzeBody(body);
if (invocation == null)
{
return;
}
if (!IsSimpleTarget(invocation.Target))
{
return;
}
var lambdaParameters = parameters.ToList();
if (lambdaParameters.Count != invocation.Arguments.Count)
{
return;
}
int i = 0;
foreach (var param in invocation.Arguments)
{
var id = param as IdentifierExpression;
if (id == null)
{
return;
}
if (lambdaParameters[i].Name != id.Identifier)
{
return;
}
i++;
}
AddIssue(expression, ctx.TranslateString("Expression can be reduced to delegate"), script => {
var validTypes = CreateFieldAction.GetValidTypes(ctx.Resolver, expression).ToList();
if (validTypes.Any(t => t.FullName == "System.Func" && t.TypeParameterCount == 1 + parameters.Count) && validTypes.Any(t => t.FullName == "System.Action"))
{
var rr = ctx.Resolve(invocation) as CSharpInvocationResolveResult;
if (rr != null && rr.Member.ReturnType.Kind != ICSharpCode.NRefactory.TypeSystem.TypeKind.Void)
{
var builder = ctx.CreateTypeSytemAstBuilder(expression);
var type = builder.ConvertType(new TopLevelTypeName("System", "Func", 1));
var args = type is SimpleType ? ((SimpleType)type).TypeArguments : ((MemberType)type).TypeArguments;
args.Clear();
foreach (var pde in parameters)
{
args.Add(builder.ConvertType(ctx.Resolve(pde).Type));
}
args.Add(builder.ConvertType(rr.Member.ReturnType));
script.Replace(expression, new CastExpression(type, invocation.Target.Clone()));
return;
}
}
script.Replace(expression, invocation.Target.Clone());
});
}
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 identifier = context.GetNode <IdentifierExpression>();
if (identifier == null)
{
yield break;
}
if (IsInvocationTarget(identifier))
{
yield break;
}
var statement = identifier.GetParent <Statement>();
if (statement == null)
{
yield break;
}
if (!(context.Resolve(identifier).IsError))
{
yield break;
}
var guessedType = CreateFieldAction.GuessAstType(context, identifier);
if (guessedType == 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(identifier.Identifier, AffectedEntity.Field, Modifiers.Private, isStatic)) {
// yield break;
// }
yield return(new CodeAction(context.TranslateString("Create field"), script => {
var decl = new FieldDeclaration()
{
ReturnType = guessedType,
Variables = { new VariableInitializer(identifier.Identifier) }
};
if (isStatic)
{
decl.Modifiers |= Modifiers.Static;
}
script.InsertWithCursor(context.TranslateString("Create field"), decl, Script.InsertPosition.Before);
}));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var expr = GetCreatePropertyOrFieldNode(context);
if (expr == null)
{
yield break;
}
if (!(expr is MemberReferenceExpression))
{
yield break;
}
var propertyName = CreatePropertyAction.GetPropertyName(expr);
if (propertyName == null)
{
yield break;
}
if (IsInvocationTarget(expr))
{
yield break;
}
var statement = expr.GetParent <Statement>();
if (statement == null)
{
yield break;
}
if (!(context.Resolve(expr).IsError))
{
yield break;
}
var guessedType = CreateFieldAction.GuessType(context, expr);
if (guessedType == null || guessedType.Kind != TypeKind.Enum)
{
yield break;
}
var state = context.GetResolverStateBefore(expr);
if (state.CurrentMember == null || state.CurrentTypeDefinition == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Create enum value"), script => {
var decl = new EnumMemberDeclaration {
Name = propertyName
};
script.InsertWithCursor(context.TranslateString("Create enum value"), guessedType.GetDefinition(), decl);
}, expr));
}
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,
identifier,
methodName,
context.CreateShortType(invocationMethod.ReturnType),
invocationMethod.Parameters.Select(parameter => new ParameterDeclaration(context.CreateShortType(parameter.Type), parameter.Name)
{
ParameterModifier = GetModifiers(parameter)
}),
false,
isStatic,
null));
}
static void ModifyClassTypeBasedOnTypeGuessing(RefactoringContext context, AstNode node, ref ClassType classType)
{
var guessedType = CreateFieldAction.GuessType(context, node);
if (guessedType.Kind == TypeKind.TypeParameter)
{
var tp = (ITypeParameter)guessedType;
if (tp.HasValueTypeConstraint)
{
classType = ClassType.Struct;
}
if (tp.HasReferenceTypeConstraint)
{
classType = ClassType.Class;
}
}
}
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 override IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var identifier = CreateFieldAction.GetCreatePropertyOrFieldNode(context);
if (identifier == null)
{
yield break;
}
if (CreateFieldAction.IsInvocationTarget(identifier))
{
yield break;
}
var propertyName = GetPropertyName(identifier);
if (propertyName == null)
{
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;
}
var state = context.GetResolverStateBefore(identifier);
if (state.CurrentTypeDefinition == null)
{
yield break;
}
bool createInOtherType = false;
ResolveResult targetResolveResult = null;
if (identifier is MemberReferenceExpression)
{
targetResolveResult = context.Resolve(((MemberReferenceExpression)identifier).Target);
if (targetResolveResult.Type.GetDefinition() == null || targetResolveResult.Type.GetDefinition().Region.IsEmpty)
{
yield break;
}
createInOtherType = !state.CurrentTypeDefinition.Equals(targetResolveResult.Type.GetDefinition());
}
bool isStatic = targetResolveResult is TypeResolveResult;
if (createInOtherType)
{
if (isStatic && targetResolveResult.Type.Kind == TypeKind.Interface || targetResolveResult.Type.Kind == TypeKind.Enum)
{
yield break;
}
}
else
{
if (state.CurrentMember == null)
{
yield break;
}
isStatic |= state.CurrentTypeDefinition.IsStatic;
if (targetResolveResult == null)
{
isStatic |= state.CurrentMember.IsStatic;
}
}
isStatic &= !(identifier is NamedExpression);
// var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
// if (service != null && !service.IsValidName(propertyName, AffectedEntity.Property, Modifiers.Private, isStatic)) {
// yield break;
// }
yield return(new CodeAction(context.TranslateString("Create property"), script => {
var decl = new PropertyDeclaration()
{
ReturnType = guessedType,
Name = propertyName,
Getter = new Accessor(),
Setter = new Accessor()
};
if (isStatic)
{
decl.Modifiers |= Modifiers.Static;
}
if (createInOtherType)
{
if (targetResolveResult.Type.Kind == TypeKind.Interface)
{
decl.Modifiers = Modifiers.None;
}
else
{
decl.Modifiers |= Modifiers.Public;
}
script.InsertWithCursor(
context.TranslateString("Create property"),
targetResolveResult.Type.GetDefinition(),
(s, c) => decl);
return;
}
script.InsertWithCursor(context.TranslateString("Create property"), Script.InsertPosition.Before, decl);
}, identifier.GetNodeAt(context.Location) ?? identifier)
{
Severity = ICSharpCode.NRefactory.Refactoring.Severity.Error
});
}
void AnalyzeExpression(AstNode expression, AstNode body, AstNodeCollection <ParameterDeclaration> parameters)
{
var invocation = AnalyzeBody(body);
if (invocation == null)
{
return;
}
if (!IsSimpleTarget(invocation.Target))
{
return;
}
var rr = ctx.Resolve(invocation) as CSharpInvocationResolveResult;
if (rr == null)
{
return;
}
var lambdaParameters = parameters.ToList();
var arguments = rr.GetArgumentsForCall();
if (lambdaParameters.Count != arguments.Count)
{
return;
}
for (int i = 0; i < arguments.Count; i++)
{
var arg = UnpackImplicitIdentityOrReferenceConversion(arguments[i]) as LocalResolveResult;
if (arg == null || arg.Variable.Name != lambdaParameters[i].Name)
{
return;
}
}
var returnConv = ctx.GetConversion(invocation);
if (returnConv.IsExplicit || !(returnConv.IsIdentityConversion || returnConv.IsReferenceConversion))
{
return;
}
AddIssue(expression, ctx.TranslateString("Expression can be reduced to delegate"), script => {
var validTypes = CreateFieldAction.GetValidTypes(ctx.Resolver, expression).ToList();
if (validTypes.Any(t => t.FullName == "System.Func" && t.TypeParameterCount == 1 + parameters.Count) && validTypes.Any(t => t.FullName == "System.Action"))
{
if (rr != null && rr.Member.ReturnType.Kind != TypeKind.Void)
{
var builder = ctx.CreateTypeSystemAstBuilder(expression);
var type = builder.ConvertType(new TopLevelTypeName("System", "Func", 1));
var args = type.GetChildrenByRole(Roles.TypeArgument);
args.Clear();
foreach (var pde in parameters)
{
args.Add(builder.ConvertType(ctx.Resolve(pde).Type));
}
args.Add(builder.ConvertType(rr.Member.ReturnType));
script.Replace(expression, new CastExpression(type, invocation.Target.Clone()));
return;
}
}
script.Replace(expression, invocation.Target.Clone());
});
}
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));
}
IEnumerable <CodeAction> GetActionsFromInvocation(RefactoringContext context, InvocationExpression invocation)
{
if (!(context.Resolve(invocation.Target).IsError))
{
yield break;
}
var methodName = GetMethodName(invocation);
if (methodName == null)
{
yield break;
}
var state = context.GetResolverStateBefore(invocation);
if (state.CurrentMember == null || state.CurrentTypeDefinition == null)
{
yield break;
}
var guessedType = invocation.Parent is ExpressionStatement ? new PrimitiveType("void") : CreateFieldAction.GuessAstType(context, invocation);
bool createInOtherType = false;
ResolveResult targetResolveResult = null;
if (invocation.Target is MemberReferenceExpression)
{
targetResolveResult = context.Resolve(((MemberReferenceExpression)invocation.Target).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 = 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,
guessedType,
GenerateParameters(context, invocation.Arguments),
createInOtherType,
isStatic,
targetResolveResult));
}
public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
var expr = GetCreatePropertyOrFieldNode(context);
if (expr == null)
{
yield break;
}
if (expr is MemberReferenceExpression && !(((MemberReferenceExpression)expr).Target is ThisReferenceExpression))
{
yield break;
}
var propertyName = CreatePropertyAction.GetPropertyName(expr);
if (propertyName == null)
{
yield break;
}
if (IsInvocationTarget(expr))
{
yield break;
}
var statement = expr.GetParent <Statement>();
if (statement == null)
{
yield break;
}
if (!(context.Resolve(expr).IsError))
{
yield break;
}
var guessedType = CreateFieldAction.GuessAstType(context, expr);
if (guessedType == null)
{
yield break;
}
var state = context.GetResolverStateBefore(expr);
if (state.CurrentMember == null || state.CurrentTypeDefinition == null)
{
yield break;
}
bool isStatic = !(expr is NamedExpression) && (state.CurrentMember.IsStatic | state.CurrentTypeDefinition.IsStatic);
// var service = (NamingConventionService)context.GetService(typeof(NamingConventionService));
// if (service != null && !service.IsValidName(identifier.Identifier, AffectedEntity.Field, Modifiers.Private, isStatic)) {
// yield break;
// }
yield return(new CodeAction(context.TranslateString("Create field"), script => {
var decl = new FieldDeclaration {
ReturnType = guessedType,
Variables = { new VariableInitializer(propertyName) }
};
if (isStatic)
{
decl.Modifiers |= Modifiers.Static;
}
script.InsertWithCursor(context.TranslateString("Create field"), Script.InsertPosition.Before, decl);
}, expr));
}
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);
}));
}