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); } }