public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var simpleType = context.GetNode <SimpleType>(); if (simpleType != null && !(simpleType.Parent is EventDeclaration || simpleType.Parent is CustomEventDeclaration)) { return(GetActions(context, simpleType)); } var createExpression = context.GetNode <ObjectCreateExpression>(); if (createExpression != null) { return(GetActions(context, createExpression)); } var identifier = context.GetNode <IdentifierExpression>(); if (identifier != null && (identifier.Parent is MemberReferenceExpression)) { return(GetActions(context, identifier)); } return(Enumerable.Empty <CodeAction>()); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var variableDeclaration = context.GetNode <VariableDeclarationStatement>(); if (variableDeclaration == null) { yield break; } var entryNode = FindCurrentScopeEntryNode(variableDeclaration); if (entryNode == null) { yield break; } var selectedInitializer = context.GetNode <VariableInitializer>(); if (selectedInitializer != null) { if (HasDependency(context, entryNode, selectedInitializer)) { yield return(MoveDeclarationAction(context, entryNode, variableDeclaration, selectedInitializer)); } else { yield return(MoveInitializerAction(context, entryNode, variableDeclaration, selectedInitializer)); } } else { yield return(new CodeAction(context.TranslateString("Move declaration to outer scope"), script => { script.Remove(variableDeclaration); script.InsertBefore(entryNode, variableDeclaration.Clone()); }, variableDeclaration)); } }
CodeAction ActionFromVariableInitializer(RefactoringContext context) { var initializer = context.GetNode <VariableInitializer>(); if (initializer == null || initializer.Parent.Parent is ForStatement) { return(null); } var initializerRR = context.Resolve(initializer) as LocalResolveResult; if (initializerRR == null) { return(null); } var elementType = GetElementType(initializerRR, context); if (elementType == null) { return(null); } return(new CodeAction(context.TranslateString("Iterate via foreach"), script => { var iterator = MakeForeach(new IdentifierExpression(initializer.Name), elementType, context); script.InsertAfter(context.GetNode <Statement>(), iterator); }, initializer)); }
public 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 = CreateFieldAction.GuessAstType(context, identifier); if (guessedType == null) { yield break; } yield return(new CodeAction(context.TranslateString("Create local variable"), script => { var initializer = new VariableInitializer(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); } })); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { // lambda var lambda = context.GetNode <LambdaExpression> (); if (lambda != null && lambda.ArrowToken.Contains(context.Location)) { if (ContainsLocalReferences(context, lambda, lambda.Body)) { yield break; } bool noReturn = false; BlockStatement body; if (lambda.Body is BlockStatement) { body = (BlockStatement)lambda.Body.Clone(); } else { body = new BlockStatement(); var type = LambdaHelper.GetLambdaReturnType(context, lambda); if (type == null || type.ReflectionName == "System.Void") { noReturn = true; body.Add(new ExpressionStatement((Expression)lambda.Body.Clone())); } else { body.Add(new ReturnStatement((Expression)lambda.Body.Clone())); } } var method = GetMethod(context, (LambdaResolveResult)context.Resolve(lambda), body, noReturn); yield return(GetAction(context, lambda, method)); } // anonymous method var anonymousMethod = context.GetNode <AnonymousMethodExpression> (); if (anonymousMethod != null && anonymousMethod.DelegateToken.Contains(context.Location)) { if (ContainsLocalReferences(context, anonymousMethod, anonymousMethod.Body)) { yield break; } var method = GetMethod(context, (LambdaResolveResult)context.Resolve(anonymousMethod), (BlockStatement)anonymousMethod.Body.Clone()); yield return(GetAction(context, anonymousMethod, method)); } }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { AstNode node = context.GetNode(); if (node is Identifier) { node = node.Parent; } if (node is SimpleType || node is IdentifierExpression) { return(GetActionsForType(context, node) .Concat(GetActionsForAddNamespaceUsing(context, node))); } else if (node is MemberReferenceExpression && node.Parent is InvocationExpression) { return(GetActionsForExtensionMethodInvocation(context, (InvocationExpression)node.Parent)); } else if (node is MemberReferenceExpression) { return(GetActionsForAddNamespaceUsing(context, node)); } else { return(EmptyList <CodeAction> .Instance); } }
static IField GetBackingField(RefactoringContext context) { var propertyDeclaration = context.GetNode <PropertyDeclaration> (); // automatic properties always need getter & setter if (propertyDeclaration == null || propertyDeclaration.Getter.IsNull || propertyDeclaration.Setter.IsNull || propertyDeclaration.Getter.Body.IsNull || propertyDeclaration.Setter.Body.IsNull) { return(null); } if (!context.Supports(csharp3) || propertyDeclaration.HasModifier(ICSharpCode.NRefactory.PlayScript.Modifiers.Abstract) || ((TypeDeclaration)propertyDeclaration.Parent).ClassType == ClassType.Interface) { return(null); } var getterField = ScanGetter(context, propertyDeclaration); if (getterField == null) { return(null); } var setterField = ScanSetter(context, propertyDeclaration); if (setterField == null) { return(null); } if (getterField.Region != setterField.Region) { return(null); } return(getterField); }
CodeAction HandleExpressionStatement(RefactoringContext context, ExpressionStatement expressionStatement) { var expression = expressionStatement.Expression as AssignmentExpression; if (expression == null || expression.Operator != AssignmentOperatorType.Assign) { return(null); } if (!(expression.Right is ObjectCreateExpression)) { return(null); } var expressionResolveResult = context.Resolve(expression.Left); if (!(expressionResolveResult is LocalResolveResult) && !(expressionResolveResult is MemberResolveResult)) { return(null); } IList <AstNode> statements = GetNodes(context.GetNode <Statement>()); var converter = new StatementsToInitializerConverter(context); var newExpression = converter.ConvertToInitializer(expression, ref statements); if (newExpression == null || statements.Count == 0) { return(null); } return(MakeAction(context, expression, newExpression, statements)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { if (context.IsSomethingSelected) { yield break; } var pexpr = context.GetNode <PrimitiveExpression>(); if (pexpr == null || !(pexpr.Value is string)) { yield break; } if (pexpr.LiteralValue.StartsWith("@", StringComparison.Ordinal)) { if (!(pexpr.StartLocation < new TextLocation(context.Location.Line, context.Location.Column - 2) && new TextLocation(context.Location.Line, context.Location.Column + 2) < pexpr.EndLocation)) { yield break; } } else { if (!(pexpr.StartLocation < new TextLocation(context.Location.Line, context.Location.Column - 1) && new TextLocation(context.Location.Line, context.Location.Column + 1) < pexpr.EndLocation)) { yield break; } } yield return(new CodeAction(context.TranslateString("Split string literal"), script => { int offset = context.GetOffset(context.Location); script.InsertText(offset, pexpr.LiteralValue.StartsWith("@", StringComparison.Ordinal) ? "\" + @\"" : "\" + \""); })); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var invocation = context.GetNode <InvocationExpression>(); if (invocation == null) { yield break; } var memberReference = invocation.Target as MemberReferenceExpression; if (memberReference == null) { yield break; } var invocationRR = context.Resolve(invocation) as CSharpInvocationResolveResult; if (invocationRR == null) { yield break; } if (invocationRR.IsExtensionMethodInvocation) { yield return(new CodeAction(context.TranslateString("Convert to call to static method"), script => { script.Replace(invocation, ToStaticMethodInvocation(invocation, memberReference, invocationRR)); }, invocation)); } }
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)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { if (context.IsSomethingSelected) { yield break; } var node = context.GetNode <VariableDeclarationStatement>(); if (node == null || node.Variables.Count != 1) { yield break; } var initializer = node.Variables.First(); if (!initializer.NameToken.Contains(context.Location) || initializer.Initializer.IsNull) { yield break; } var resolveResult = context.Resolve(initializer) as LocalResolveResult; if (resolveResult == null || resolveResult.IsError) { yield break; } var unit = context.RootNode as SyntaxTree; if (unit == null) { yield break; } yield return(new CodeAction(context.TranslateString("Inline local variable"), script => { refFinder.FindLocalReferences(resolveResult.Variable, context.UnresolvedFile, unit, context.Compilation, (n, r) => script.Replace(n, AddParensIfRequired(n, initializer.Initializer.Clone())), default(CancellationToken)); script.Remove(node); }, initializer)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var catchClause = context.GetNode <CatchClause>(); if (catchClause == null) { yield break; } if (!catchClause.Type.IsNull) { yield break; } yield return(new CodeAction(context.TranslateString("Add type specifier"), script => { var newType = context.CreateShortType("System", "Exception"); var namingHelper = new NamingHelper(context); var newIdentifier = Identifier.Create(namingHelper.GenerateVariableName(newType, "e")); script.Replace(catchClause, new CatchClause { Type = newType, VariableNameToken = newIdentifier, Body = catchClause.Body.Clone() as BlockStatement }); script.Select(newType); })); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { if (!context.IsSomethingSelected) { yield break; } var pexpr = context.GetNode <PrimitiveExpression>(); if (pexpr == null || !(pexpr.Value is string)) { yield break; } if (pexpr.LiteralValue.StartsWith("@", StringComparison.Ordinal)) { if (!(pexpr.StartLocation < new TextLocation(context.Location.Line, context.Location.Column - 1) && new TextLocation(context.Location.Line, context.Location.Column + 1) < pexpr.EndLocation)) { yield break; } } else { if (!(pexpr.StartLocation < context.Location && context.Location < pexpr.EndLocation)) { yield break; } } yield return(new CodeAction(context.TranslateString("Introduce format item"), script => { var invocation = context.GetNode <InvocationExpression>(); if (invocation != null && invocation.Target.IsMatch(PrototypeFormatReference)) { AddFormatCallToInvocation(context, script, pexpr, invocation); return; } var arg = CreateFormatArgument(context); var newInvocation = new InvocationExpression(PrototypeFormatReference.Clone()) { Arguments = { CreateFormatString(context, pexpr, 0), arg } }; script.Replace(pexpr, newInvocation); script.Select(arg); })); }
static PropertyDeclaration GetPropertyDeclaration(RefactoringContext context) { var node = context.GetNode(); if (node == null) { return(null); } return(node.Parent as PropertyDeclaration); }
static PreProcessorDirective GetDirective(RefactoringContext context) { var directive = context.GetNode <PreProcessorDirective> (); if (directive == null || directive.Type != PreProcessorDirectiveType.Region) { return(null); } return(directive); }
static ForeachStatement GetForeachStatement(RefactoringContext context) { var result = context.GetNode <ForeachStatement> (); if (result != null && result.VariableType.Contains(context.Location) && result.VariableType.IsMatch(varType)) { return(result); } return(null); }
static IfElseStatement GetIfElseStatement(RefactoringContext context) { var result = context.GetNode <IfElseStatement> (); if (result != null && result.IfToken.Contains(context.Location)) { return(result); } return(null); }
static PrimitiveExpression GetEmptyString(RefactoringContext context) { var node = context.GetNode <PrimitiveExpression> (); if (node == null || !(node.Value is string) || node.Value.ToString() != "") { return(null); } return(node); }
static VariableDeclarationStatement GetVariableDeclarationStatement(RefactoringContext context) { var result = context.GetNode <VariableDeclarationStatement> (); if (result != null && result.Variables.Count == 1 && !result.Variables.First().Initializer.IsNull&& result.Type.Contains(context.Location) && !result.Type.IsMatch(varType)) { return(result); } return(null); }
static SwitchStatement GetSwitchStatement(RefactoringContext context) { var switchStatment = context.GetNode <SwitchStatement> (); if (switchStatment != null && switchStatment.SwitchSections.Count == 0) { return(switchStatment); } return(null); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var simpleType = context.GetNode <SimpleType>(); if (simpleType != null && (simpleType.Parent is EventDeclaration || simpleType.Parent is CustomEventDeclaration)) { return(GetActions(context, simpleType)); } return(Enumerable.Empty <CodeAction>()); }
public NamingHelper(RefactoringContext context) { this.context = context; if (usedVariableNames == null) { var visitor = new VariableFinderVisitor(); var astNode = context.GetNode <Statement>(); astNode.AcceptVisitor(visitor); usedVariableNames = visitor.VariableNames; } }
static EventDeclaration GetEventDeclaration(RefactoringContext context, out VariableInitializer initializer) { var result = context.GetNode <EventDeclaration> (); if (result == null) { initializer = null; return(null); } initializer = result.Variables.FirstOrDefault(v => v.NameToken.Contains(context.Location)); return(initializer != null ? result : null); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var property = context.GetNode <PropertyDeclaration>(); if (!(property != null && !property.Getter.IsNull && !property.Setter.IsNull && // automatic properties always need getter & setter property.Getter.Body.IsNull && property.Setter.Body.IsNull)) { yield break; } yield return(new CodeAction(context.TranslateString("Create backing store"), script => { string backingStoreName = context.GetNameProposal(property.Name); // create field var backingStore = new FieldDeclaration(); if (property.Modifiers.HasFlag(Modifiers.Static)) { backingStore.Modifiers |= Modifiers.Static; } backingStore.ReturnType = property.ReturnType.Clone(); var initializer = new VariableInitializer(backingStoreName); backingStore.Variables.Add(initializer); // create new property & implement the get/set bodies var newProperty = (PropertyDeclaration)property.Clone(); Expression id1; if (backingStoreName == "value") { id1 = new ThisReferenceExpression().Member("value"); } else { id1 = new IdentifierExpression(backingStoreName); } Expression id2 = id1.Clone(); newProperty.Getter.Body = new BlockStatement() { new ReturnStatement(id1) }; newProperty.Setter.Body = new BlockStatement() { new AssignmentExpression(id2, AssignmentOperatorType.Assign, new IdentifierExpression("value")) }; script.Replace(property, newProperty); script.InsertBefore(property, backingStore); script.Link(initializer, id1, id2); }, property.NameToken)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { // field, local var, event, fixed var, fixed field // local variable var variableDecl = context.GetNode <VariableDeclarationStatement> (); if (variableDecl != null && variableDecl.Parent is BlockStatement) { return(GetAction(context, variableDecl, v => v.Variables)); } // field var fieldDecl = context.GetNode <FieldDeclaration> (); if (fieldDecl != null) { return(GetAction(context, fieldDecl, f => f.Variables)); } // event var eventDecl = context.GetNode <EventDeclaration> (); if (eventDecl != null) { return(GetAction(context, eventDecl, e => e.Variables)); } // fixed field var fixedFieldDecl = context.GetNode <FixedFieldDeclaration> (); if (fixedFieldDecl != null) { return(GetAction(context, fixedFieldDecl, f => f.Variables)); } return(Enumerable.Empty <CodeAction> ()); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var initializer = context.GetNode <VariableInitializer>(); if (initializer != null) { var action = HandleInitializer(context, initializer); if (action != null) { yield return(action); } } var expressionStatement = context.GetNode <ExpressionStatement>(); if (expressionStatement != null) { var action = HandleExpressionStatement(context, expressionStatement); if (action != null) { yield return(action); } } }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var identifier = context.GetNode <IdentifierExpression>(); if (identifier != null && !(identifier.Parent is InvocationExpression && ((InvocationExpression)identifier.Parent).Target == identifier)) { return(GetActionsFromIdentifier(context, identifier)); } var memberReference = context.GetNode <MemberReferenceExpression>(); if (memberReference != null && !(memberReference.Parent is InvocationExpression && ((InvocationExpression)memberReference.Parent).Target == memberReference)) { return(GetActionsFromMemberReferenceExpression(context, memberReference)); } var invocation = context.GetNode <InvocationExpression>(); if (invocation != null) { return(GetActionsFromInvocation(context, invocation)); } return(Enumerable.Empty <CodeAction>()); }
public System.Collections.Generic.IEnumerable <CodeAction> GetActions(RefactoringContext context) { var node = context.GetNode <T>(); if (node == null) { yield break; } var action = GetAction(context, node); if (action == null) { yield break; } yield return(action); }
public static BinaryOperatorExpression GetBinaryOperatorExpression(RefactoringContext context) { var node = context.GetNode <BinaryOperatorExpression> (); if (node == null || !node.OperatorToken.Contains(context.Location)) { return(null); } var result = node as BinaryOperatorExpression; if (result == null || (result.Operator != BinaryOperatorType.Equality && result.Operator != BinaryOperatorType.InEquality)) { return(null); } return(result); }