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>()); }
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); })); }
public override System.Collections.Generic.IEnumerable <CodeAction> GetActions(RefactoringContext context) { var expression = context.GetNode(i => i is BinaryOperatorExpression || i is UnaryOperatorExpression); if (expression == null) { yield break; } var node = context.GetNode(); if (node == null || !(node is PrimitiveExpression) && node.StartLocation != context.Location) { yield break; } var rr = context.Resolve(expression); if (rr.ConstantValue == null) { yield break; } yield return(new CodeAction( context.TranslateString("Compute constant value"), script => script.Replace(expression, new PrimitiveExpression(rr.ConstantValue)), node )); }
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()); })); } }
public override IEnumerable <CodeAction> GetActions(RefactoringContext context) { Expression node = context.GetNode <IdentifierExpression>(); if (node == null) { var mr = context.GetNode <MemberReferenceExpression>(); if (mr == null || !mr.MemberNameToken.IsInside(context.Location)) { yield break; } node = mr; } if (node == null) { yield break; } var rr = context.Resolve(node) as MethodGroupResolveResult; if (rr == null || rr.IsError) { yield break; } var type = TypeGuessing.GetValidTypes(context.Resolver, node).FirstOrDefault(t => t.Kind == TypeKind.Delegate); if (type == null) { yield break; } var invocationMethod = type.GetDelegateInvokeMethod(); if (invocationMethod == null) { yield break; } yield return(new CodeAction( context.TranslateString("Convert to anonymous method"), script => { var expr = new InvocationExpression(node.Clone(), invocationMethod.Parameters.Select(p => new IdentifierExpression(context.GetNameProposal(p.Name)))); var stmt = invocationMethod.ReturnType.IsKnownType(KnownTypeCode.Void) ? (Statement)expr : new ReturnStatement(expr); var anonymousMethod = new AnonymousMethodExpression { Body = new BlockStatement { stmt } }; foreach (var p in invocationMethod.Parameters) { var decl = new ParameterDeclaration(context.CreateShortType(p.Type), context.GetNameProposal(p.Name)); anonymousMethod.Parameters.Add(decl); } script.Replace(node, anonymousMethod); }, node )); }
public override 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 { if (!(lambda.Body is Expression)) { yield break; } body = new BlockStatement(); var type = LambdaHelper.GetLambdaReturnType(context, lambda); if (type == null || type.ReflectionName == "System.Void") { noReturn = true; body.Add((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 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 override IEnumerable <CodeAction> GetActions(RefactoringContext context) { Expression node = context.GetNode <IdentifierExpression>(); if (node == null) { var mr = context.GetNode <MemberReferenceExpression>(); if (mr == null || !mr.MemberNameToken.IsInside(context.Location)) { yield break; } node = mr; } if (node == null) { yield break; } var rr = context.Resolve(node) as MethodGroupResolveResult; if (rr == null || rr.IsError) { yield break; } var type = TypeGuessing.GetValidTypes(context.Resolver, node).FirstOrDefault(t => t.Kind == TypeKind.Delegate); if (type == null) { yield break; } var invocationMethod = type.GetDelegateInvokeMethod(); if (invocationMethod == null) { yield break; } yield return(new CodeAction( context.TranslateString("Convert to lambda expression"), script => { var invocation = new InvocationExpression(node.Clone(), invocationMethod.Parameters.Select(p => new IdentifierExpression(context.GetNameProposal(p.Name)))); var lambda = new LambdaExpression { Body = invocation }; lambda.Parameters.AddRange( invocation.Arguments .Cast <IdentifierExpression>() .Select(p => new ParameterDeclaration { Name = p.Identifier }) ); script.Replace(node, lambda); }, node )); }
public override IEnumerable <CodeAction> GetActions(RefactoringContext context) { var property = context.GetNode <PropertyDeclaration>(); if (property == null || !property.NameToken.Contains(context.Location)) { yield break; } var field = GetBackingField(context); if (field == null) { yield break; } // create new auto property var newProperty = (PropertyDeclaration)property.Clone(); newProperty.Getter.Body = BlockStatement.Null; newProperty.Setter.Body = BlockStatement.Null; yield return(new CodeAction(context.TranslateString("Convert to auto property"), script => { script.Rename((IEntity)field, newProperty.Name); script.Remove(context.RootNode.GetNodeAt <FieldDeclaration> (field.Region.Begin)); script.Replace(property, newProperty); }, property.NameToken)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var type = context.GetNode <AstType>(); if (type == null || type.Role != Roles.BaseType) { yield break; } var state = context.GetResolverStateBefore(type); if (state.CurrentTypeDefinition == null) { yield break; } var resolveResult = context.Resolve(type); if (resolveResult.Type.Kind != TypeKind.Class || resolveResult.Type.GetDefinition() == null || !resolveResult.Type.GetDefinition().IsAbstract) { yield break; } yield break; /* * yield return new CodeAction(context.TranslateString("Implement abstract members"), script => { * script.InsertWithCursor( * context.TranslateString("Implement abstract members"), * state.CurrentTypeDefinition, * ImplementInterfaceAction.GenerateImplementation (context, toImplement) * ); * });*/ }
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); }, catchClause)); }
public IEnumerable<CodeAction> GetActions(RefactoringContext context) { var type = context.GetNode<AstType>(); if (type == null || type.Role != Roles.BaseType) yield break; var state = context.GetResolverStateBefore(type); if (state.CurrentTypeDefinition == null) yield break; var resolveResult = context.Resolve(type); if (resolveResult.Type.Kind != TypeKind.Class || resolveResult.Type.GetDefinition() == null || !resolveResult.Type.GetDefinition().IsAbstract) yield break; var toImplement = CollectMembersToImplement(state.CurrentTypeDefinition, resolveResult.Type); if (toImplement.Count == 0) yield break; yield return new CodeAction(context.TranslateString("Implement abstract members"), script => { script.InsertWithCursor( context.TranslateString("Implement abstract members"), state.CurrentTypeDefinition, ImplementInterfaceAction.GenerateImplementation (context, toImplement.Select (m => Tuple.Create (m, false))).Select (entity => { var decl = entity as EntityDeclaration; if (decl != null) decl.Modifiers |= Modifiers.Override; return entity; }) ); }, type); }
public override IEnumerable <CodeAction> GetActions(RefactoringContext context) { var entity = context.GetNode <ConstructorDeclaration>(); if (entity == null) { yield break; } var type = entity.Parent as TypeDeclaration; if (type == null || entity.Name == type.Name) { yield break; } var typeDeclaration = entity.GetParent <TypeDeclaration>(); yield return(new CodeAction(context.TranslateString("This is a constructor"), script => { script.Replace(entity.NameToken, Identifier.Create(typeDeclaration.Name, TextLocation.Empty)); }, entity)); yield return(new CodeAction(context.TranslateString("This is a void method"), script => { var generatedMethod = new MethodDeclaration(); generatedMethod.Modifiers = entity.Modifiers; generatedMethod.ReturnType = new PrimitiveType("void"); generatedMethod.Name = entity.Name; generatedMethod.Parameters.AddRange(entity.Parameters.Select(parameter => (ParameterDeclaration)parameter.Clone())); generatedMethod.Body = (BlockStatement)entity.Body.Clone(); generatedMethod.Attributes.AddRange(entity.Attributes.Select(attribute => (AttributeSection)attribute.Clone())); script.Replace(entity, generatedMethod); }, entity)); }
public void Run(RefactoringContext context) { var property = context.GetNode <PropertyDeclaration> (); string backingStoreName = context.GetNameProposal(property.Name); // create field var backingStore = new FieldDeclaration(); 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(); var id1 = new IdentifierExpression(backingStoreName); var id2 = new IdentifierExpression(backingStoreName); newProperty.Getter.Body = new BlockStatement() { new ReturnStatement(id1) }; newProperty.Setter.Body = new BlockStatement() { new ExpressionStatement(new AssignmentExpression(id2, AssignmentOperatorType.Assign, new IdentifierExpression("value"))) }; using (var script = context.StartScript()) { script.Replace(property, newProperty); script.InsertBefore(property, backingStore); script.Link(initializer, id1, id2); } }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var initializer = context.GetNode <VariableInitializer>(); if (initializer == null || !initializer.NameToken.Contains(context.Location.Line, context.Location.Column)) { yield break; } var type = initializer.Parent.Parent as TypeDeclaration; if (type == null) { yield break; } foreach (var member in type.Members) { if (member is PropertyDeclaration && ContainsGetter((PropertyDeclaration)member, initializer)) { yield break; } } var field = initializer.Parent as FieldDeclaration; if (field == null) { yield break; } yield return(new CodeAction(context.TranslateString("Create property"), script => { script.InsertWithCursor(context.TranslateString("Create property"), GeneratePropertyDeclaration(context, field, initializer), Script.InsertPosition.After); })); }
public override IEnumerable <CodeAction> GetActions(RefactoringContext context) { var ifStatement = context.GetNode <IfElseStatement>(); if (ifStatement == null) { yield break; } var bOp = ifStatement.GetNodeAt <BinaryOperatorExpression>(context.Location); if (bOp == null || !bOp.OperatorToken.Contains(context.Location)) { yield break; } if (bOp.Ancestors.OfType <BinaryOperatorExpression>().Any(b => b.Operator != bOp.Operator)) { yield break; } if (bOp.Operator == BinaryOperatorType.ConditionalAnd) { yield return(CreateAndSplit(context, ifStatement, bOp)); } else if (bOp.Operator == BinaryOperatorType.ConditionalOr) { yield return(CreateOrSplit(context, ifStatement, bOp)); } }
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"), decl, resolveResult.Member.DeclaringTypeDefinition); })); }
public override 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 static method call"), script => { script.Replace(invocation, ToStaticMethodInvocation(invocation, memberReference, invocationRR)); }, invocation)); } }
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 override 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)); }
internal 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.CSharp.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.Equals(setterField)) { return(null); } return(getterField); }
public override IEnumerable <CodeAction> GetActions(RefactoringContext context) { var method = context.GetNode <MethodDeclaration>(); if (method == null || !method.NameToken.Contains(context.Location)) { yield break; } if (method.HasModifier(Modifiers.Static)) { yield break; } var param = method.Parameters.FirstOrDefault(); if (param == null || param.ParameterModifier != ParameterModifier.This) { yield break; } yield return(new CodeAction( context.TranslateString("Convert method to static"), script => script.ChangeModifier(method, method.Modifiers | Modifiers.Static), method) { Severity = ICSharpCode.NRefactory.Refactoring.Severity.Error }); }
public override 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); } }
public override 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) ? "\" + @\"" : "\" + \""); }, pexpr); }
public override IEnumerable <CodeAction> GetActions(RefactoringContext context) { string keyword; Statement embeddedStatement; // BlockStatement block; var curNode = context.GetNode(); if (!RemoveBracesAction.IsSpecialNode(curNode, out keyword, out embeddedStatement)) { yield break; } if (embeddedStatement is BlockStatement) { yield break; } yield return(new CodeAction( string.Format(context.TranslateString("Add braces to '{0}'"), keyword), script => { script.Replace(embeddedStatement, new BlockStatement { embeddedStatement.Clone() }); }, curNode )); }
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); }, pexpr)); }
public void Run(RefactoringContext context) { var pexpr = context.GetNode <PrimitiveExpression> (); int offset = context.GetOffset(context.Location); using (var script = context.StartScript()) { script.InsertText(offset, pexpr.LiteralValue.StartsWith("@") ? "\" + @\"" : "\" + \""); } }
public bool IsValid(RefactoringContext context) { var propertyDeclaration = context.GetNode <PropertyDeclaration> (); return(propertyDeclaration != null && !propertyDeclaration.Getter.IsNull && !propertyDeclaration.Setter.IsNull && // automatic properties always need getter & setter propertyDeclaration.Getter.Body.IsNull && propertyDeclaration.Setter.Body.IsNull); }
public override IEnumerable <CodeAction> GetActions(RefactoringContext context) { var property = context.GetNode <PropertyDeclaration>(); if (property == null || !property.NameToken.Contains(context.Location)) { yield break; } if (!(!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)); }
static PrimitiveExpression GetEmptyString(RefactoringContext context) { var node = context.GetNode <PrimitiveExpression> (); if (node == null || !(node.Value is string) || node.Value.ToString() != "") { return(null); } return(node); }