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)); } }
protected override CodeAction GetAction(RefactoringContext context, CastExpression node) { if (node.Expression.Contains(context.Location)) { return(null); } // only works on reference and nullable types var type = context.ResolveType(node.Type); var typeDef = type.GetDefinition(); var isNullable = typeDef != null && typeDef.KnownTypeCode == KnownTypeCode.NullableOfT; if (type.IsReferenceType == true || isNullable) { return(new CodeAction(context.TranslateString("Convert cast to 'as'"), script => { var asExpr = new AsExpression(node.Expression.Clone(), node.Type.Clone()); // if parent is an expression, clone parent and replace the case expression with asExpr, // so that we can inset parentheses var parentExpr = node.Parent.Clone() as Expression; if (parentExpr != null) { var castExpr = parentExpr.GetNodeContaining(node.StartLocation, node.EndLocation); castExpr.ReplaceWith(asExpr); parentExpr.AcceptVisitor(insertParentheses); script.Replace(node.Parent, parentExpr); } else { script.Replace(node, asExpr); } }, node)); } return(null); }
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 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 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 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 || field.HasModifier(Modifiers.Readonly) || field.HasModifier(Modifiers.Const)) { yield break; } var resolveResult = context.Resolve(initializer) as MemberResolveResult; if (resolveResult == null) { yield break; } yield return(new CodeAction(context.TranslateString("Create property"), script => { var fieldName = context.GetNameProposal(initializer.Name, true); if (initializer.Name == context.GetNameProposal(initializer.Name, false)) { script.Rename(resolveResult.Member, fieldName); } script.InsertWithCursor( context.TranslateString("Create property"), Script.InsertPosition.After, GeneratePropertyDeclaration(context, field, fieldName)); })); }
CodeAction MakeAction(RefactoringContext context, AstNode oldNode, AstNode replacementNode, IEnumerable <AstNode> toRemove) { return(new CodeAction(context.TranslateString("Convert to initializer"), script => { foreach (var statement in toRemove) { script.Remove(statement); } script.Replace(oldNode, replacementNode); })); }
CodeAction GetAction(RefactoringContext context, AstNode node, MethodDeclaration method) { return(new CodeAction(context.TranslateString("Extract anonymous method"), script => { var identifier = new IdentifierExpression("Method"); script.Replace(node, identifier); script.InsertBefore(node.GetParent <EntityDeclaration> (), method); script.Link(method.NameToken, identifier); })); }
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.Interface) { yield break; } var toImplement = ImplementInterfaceAction.CollectMembersToImplement( state.CurrentTypeDefinition, resolveResult.Type, false ); if (toImplement.Count == 0) { yield break; } yield return(new CodeAction(context.TranslateString("Implement interface explicit"), script => { script.InsertWithCursor( context.TranslateString("Implement Interface"), state.CurrentTypeDefinition, ImplementInterfaceAction.GenerateImplementation(context, toImplement.Select(t => Tuple.Create(t.Item1, true))) ); })); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var switchStatement = GetSwitchStatement(context); if (switchStatement == null) { yield break; } var result = context.Resolve(switchStatement.Expression); if (result.Type.Kind != TypeKind.Enum) { yield break; } yield return(new CodeAction(context.TranslateString("Create switch labels"), script => { var type = result.Type; var newSwitch = (SwitchStatement)switchStatement.Clone(); var target = new TypeReferenceExpression(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); })); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var expr = GetEmptyString(context); if (expr == null) { yield break; } yield return(new CodeAction(context.TranslateString("Use string.Empty"), script => { script.Replace(expr, new MemberReferenceExpression(new TypeReferenceExpression(new PrimitiveType("string")), "Empty")); }, expr)); }
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) { 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)); }
static IEnumerable <CodeAction> GetActions(RefactoringContext context, SimpleType node) { var resolveResult = context.Resolve(node) as UnknownIdentifierResolveResult; if (resolveResult == null) { yield break; } yield return(new CodeAction(context.TranslateString("Create delegate"), script => { script.CreateNewType(CreateType(context, node)); })); }
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) { VariableInitializer initializer; var eventDeclaration = GetEventDeclaration(context, out initializer); if (eventDeclaration == null) { yield break; } var type = (TypeDeclaration)eventDeclaration.Parent; var proposedHandlerName = GetNameProposal(initializer); if (type.Members.Any(m => m is 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 => { var methodDeclaration = CreateEventInvocator(context, type, eventDeclaration, initializer, invokeMethod, UseExplictType); script.InsertWithCursor( context.TranslateString("Create event invocator"), Script.InsertPosition.After, methodDeclaration ); }, initializer)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var binop = GetBinaryOperatorExpression(context); if (binop == null) { yield break; } yield return(new CodeAction(string.Format(context.TranslateString("Flip '{0}' operator arguments"), binop.OperatorToken.GetText()), script => { script.Replace(binop.Left, binop.Right.Clone()); script.Replace(binop.Right, binop.Left.Clone()); })); }
static CodeAction MoveDeclarationAction(RefactoringContext context, AstNode insertAnchor, VariableDeclarationStatement declarationStatement, VariableInitializer initializer) { var type = declarationStatement.Type.Clone(); var name = initializer.Name; return(new CodeAction(context.TranslateString("Move declaration to outer scope"), script => { script.InsertBefore(declarationStatement, new ExpressionStatement() { Expression = new AssignmentExpression(new IdentifierExpression(name), initializer.Initializer.Clone()) }); script.Remove(declarationStatement); script.InsertBefore(insertAnchor, new VariableDeclarationStatement(type, name, Expression.Null)); })); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var pdecl = GetPropertyDeclaration(context); if (pdecl == null || !pdecl.Getter.IsNull && !pdecl.Setter.IsNull) { yield break; } var type = pdecl.Parent as TypeDeclaration; if (type != null && type.ClassType == ClassType.Interface) { yield break; } yield return(new CodeAction(pdecl.Setter.IsNull ? context.TranslateString("Add setter") : context.TranslateString("Add getter"), script => { Statement accessorStatement = null; var accessor = new Accessor(); if (!pdecl.Getter.IsNull && !pdecl.Getter.Body.IsNull || !pdecl.Setter.IsNull && !pdecl.Setter.Body.IsNull) { accessorStatement = BuildAccessorStatement(context, pdecl); accessor.Body = new BlockStatement { accessorStatement }; } accessor.Role = pdecl.Setter.IsNull ? PropertyDeclaration.SetterRole : PropertyDeclaration.GetterRole; if (pdecl.Setter.IsNull && !pdecl.Getter.IsNull) { script.InsertAfter(pdecl.Getter, accessor); } else if (pdecl.Getter.IsNull && !pdecl.Setter.IsNull) { script.InsertBefore(pdecl.Setter, accessor); } else { script.InsertBefore(pdecl.Getter, accessor); } if (accessorStatement != null) { script.Select(accessorStatement); } script.FormatText(pdecl); }, pdecl.NameToken)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { // if (condition) {CodeBlock();}else { return|break|continue;} // will be reduced to: //if (!condition) return|break|continue; //CodeBlock(); var ifStatement = GetIfElseStatement(context); if (ifStatement == null) { yield break; } yield return(new CodeAction(context.TranslateString("Simplify if in loops"), script => GenerateNewScript( script, ifStatement), ifStatement)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { // TODO: Invert if without else // ex. if (cond) DoSomething () == if (!cond) return; DoSomething () // beware of loop contexts return should be continue then. var ifStatement = GetIfElseStatement(context); if (ifStatement == null) { yield break; } yield return(new CodeAction(context.TranslateString("Invert if"), script => { GenerateNewScript(script, ifStatement); }, ifStatement)); }
CodeAction GetAction <T> (RefactoringContext context, IfElseStatement ifElseStatement, Func <Statement, T> extractor, Func <T, T, Statement> getReplaceStatement, bool findImplicitFalseStatement = false) where T : AstNode { var node1 = GetNode(ifElseStatement.TrueStatement, extractor); if (node1 == null) { return(null); } var falseStatement = ifElseStatement.FalseStatement; // try next statement if there is no FalseStatement if (falseStatement.IsNull && findImplicitFalseStatement) { falseStatement = ifElseStatement.GetNextSibling(n => n is Statement) as Statement; } var node2 = GetNode(falseStatement, extractor); if (node2 == null) { return(null); } var replacement = getReplaceStatement(node1, node2); if (replacement == null) { return(null); } return(new CodeAction(context.TranslateString("Convert 'if' to '?:'"), script => { script.Replace(ifElseStatement, replacement); // remove implicit false statement if (falseStatement != ifElseStatement.FalseStatement) { script.Remove(falseStatement); } }, ifElseStatement )); }
static CodeAction MoveInitializerAction(RefactoringContext context, AstNode insertAnchor, VariableDeclarationStatement declaration, VariableInitializer initializer) { var type = declaration.Type.Clone(); var name = initializer.Name; return(new CodeAction(context.TranslateString("Move initializer to outer scope"), script => { if (declaration.Variables.Count != 1) { var innerDeclaration = RemoveInitializer(declaration, initializer); script.InsertBefore(declaration, innerDeclaration); } script.Remove(declaration); var outerDeclaration = new VariableDeclarationStatement(type, name, initializer.Initializer.Clone()); script.InsertBefore(insertAnchor, outerDeclaration); })); }
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); })); }
protected override CodeAction GetAction(RefactoringContext context, LambdaExpression node) { if (context.Location < node.StartLocation || context.Location >= node.Body.StartLocation) { return(null); } var lambdaResolveResult = context.Resolve(node) as LambdaResolveResult; if (lambdaResolveResult == null) { return(null); } return(new CodeAction(context.TranslateString("Convert to anonymous delegate"), script => { BlockStatement newBody; if (node.Body is BlockStatement) { newBody = (BlockStatement)node.Body.Clone(); } else { var expression = (Expression)node.Body.Clone(); Statement statement; if (RequireReturnStatement(context, node)) { statement = new ReturnStatement(expression); } else { statement = new ExpressionStatement(expression); } newBody = new BlockStatement { Statements = { statement } }; } var method = new AnonymousMethodExpression(newBody, GetParameters(lambdaResolveResult.Parameters, context)); script.Replace(node, method); }, node)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var pexpr = context.GetNode <PrimitiveExpression>(); if (pexpr == null || !pexpr.LiteralValue.StartsWith("0X", System.StringComparison.OrdinalIgnoreCase)) { yield break; } if (!((pexpr.Value is int) || (pexpr.Value is long) || (pexpr.Value is short) || (pexpr.Value is sbyte) || (pexpr.Value is uint) || (pexpr.Value is ulong) || (pexpr.Value is ushort) || (pexpr.Value is byte))) { yield break; } yield return(new CodeAction(context.TranslateString("Convert hex to dec"), script => { script.Replace(pexpr, new PrimitiveExpression(pexpr.Value)); })); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { var directive = GetDirective(context); if (directive == null) { yield break; } var endDirective = DirectiveSearcher.GetEndRegion(context.RootNode, directive); if (endDirective == null) { yield break; } yield return(new CodeAction(context.TranslateString("Remove region"), script => { script.Remove(directive); script.Remove(endDirective); }, directive)); }
public IEnumerable <CodeAction> GetActions(RefactoringContext context) { // TODO: Invert if without else // ex. if (cond) DoSomething () == if (!cond) return; DoSomething () // beware of loop contexts return should be continue then. var ifStatement = GetIfElseStatement(context); if (!(ifStatement != null && !ifStatement.TrueStatement.IsNull && !ifStatement.FalseStatement.IsNull)) { yield break; } yield return(new CodeAction(context.TranslateString("Invert if"), script => { script.Replace(ifStatement.Condition, CSharpUtil.InvertCondition(ifStatement.Condition.Clone())); script.Replace(ifStatement.TrueStatement, ifStatement.FalseStatement.Clone()); script.Replace(ifStatement.FalseStatement, ifStatement.TrueStatement.Clone()); script.FormatText(ifStatement); })); }
CodeAction ActionFromUsingStatement(RefactoringContext context) { var initializer = context.GetNode <VariableInitializer>(); if (initializer == null) { return(null); } var initializerRR = context.Resolve(initializer) as LocalResolveResult; if (initializerRR == null) { return(null); } var elementType = GetElementType(initializerRR, context); if (elementType == null) { return(null); } var usingStatement = initializer.Parent.Parent as UsingStatement; if (usingStatement == null) { return(null); } return(new CodeAction(context.TranslateString("Iterate via foreach"), script => { var iterator = MakeForeach(new IdentifierExpression(initializer.Name), elementType, context); if (usingStatement.EmbeddedStatement is EmptyStatement) { var blockStatement = new BlockStatement(); blockStatement.Statements.Add(iterator); script.Replace(usingStatement.EmbeddedStatement, blockStatement); script.FormatText((AstNode)blockStatement); } else if (usingStatement.EmbeddedStatement is BlockStatement) { var anchorNode = usingStatement.EmbeddedStatement.FirstChild; script.InsertAfter(anchorNode, iterator); script.FormatText(usingStatement.EmbeddedStatement); } }, initializer)); }
protected override CodeAction GetAction(RefactoringContext context, IfElseStatement node) { if (!node.IfToken.Contains(context.Location)) { return(null); } IfElseStatement outerIfStatement; IfElseStatement innerIfStatement = GetInnerIfStatement(node); if (innerIfStatement != null) { if (!innerIfStatement.FalseStatement.IsNull) { return(null); } outerIfStatement = node; } else { outerIfStatement = GetOuterIfStatement(node); if (outerIfStatement == null || !outerIfStatement.FalseStatement.IsNull) { return(null); } innerIfStatement = node; } return(new CodeAction(context.TranslateString("Merge nested 'if's"), script => { var mergedIfStatement = new IfElseStatement { Condition = new BinaryOperatorExpression(outerIfStatement.Condition.Clone(), BinaryOperatorType.ConditionalAnd, innerIfStatement.Condition.Clone()), TrueStatement = innerIfStatement.TrueStatement.Clone() }; mergedIfStatement.Condition.AcceptVisitor(insertParenthesesVisitor); script.Replace(outerIfStatement, mergedIfStatement); }, node)); }