public virtual string ConstructLinesOfProc(ICodeModule codeModule, IExtractMethodModel model)
{
var newLine = Environment.NewLine;
var method = model.Method;
var keyword = Tokens.Sub;
var asTypeClause = string.Empty;
var selection = model.RowsToRemove;
var access = method.Accessibility.ToString();
var extractedParams = method.Parameters.Select(p => ExtractedParameter.PassedBy.ByRef + " " + p.Name + " " + Tokens.As + " " + p.TypeName);
var parameters = "(" + string.Join(", ", extractedParams) + ")";
//method signature
var result = access + ' ' + keyword + ' ' + method.MethodName + parameters + ' ' + asTypeClause + newLine;
// method body
string textToMove = "";
foreach (var item in selection)
{
textToMove += codeModule.GetLines(item.StartLine, item.EndLine - item.StartLine + 1);
textToMove += Environment.NewLine;
}
// method end;
result += textToMove;
result += Tokens.End + " " + Tokens.Sub;
return(result);
}
private void SetFieldToPrivate(ICodeModule module)
{
if (_model.TargetDeclaration.Accessibility == Accessibility.Private)
{
return;
}
RemoveField(_model.TargetDeclaration);
var newField = "Private " + _model.TargetDeclaration.IdentifierName + " As " +
_model.TargetDeclaration.AsTypeName;
module.InsertLines(module.CountOfDeclarationLines + 1, newField);
var pane = module.CodePane;
{
pane.Selection = _model.TargetDeclaration.QualifiedSelection.Selection;
}
for (var index = 1; index <= module.CountOfDeclarationLines; index++)
{
if (module.GetLines(index, 1).Trim() == string.Empty)
{
module.DeleteLines(new Selection(index, 0, index, 0));
}
}
}
public void SetSelection(ICodeModule module, Selection selection)
{
using (var pane = module.CodePane)
{
pane.Selection = selection;
}
}
public static void ReplaceToken(this ICodeModule module, IToken token, string replacement)
{
var original = module.GetLines(token.Line, 1);
var result = ReplaceStringAtIndex(original, token.Text, replacement, token.Column);
module.ReplaceLine(token.Line, result);
}
public static void ReplaceIdentifierReferenceName(this ICodeModule module, IdentifierReference identifierReference, string replacement)
{
var original = module.GetLines(identifierReference.Selection.StartLine, 1);
var result = ReplaceStringAtIndex(original, identifierReference.IdentifierName, replacement, identifierReference.Context.Start.Column);
module.ReplaceLine(identifierReference.Selection.StartLine, result);
}
public static bool HasEqualCodeModule(this IVBComponent component, ICodeModule otherCodeModule)
{
using (var codeModule = component.CodeModule)
{
return(codeModule.Equals(otherCodeModule));
}
}
public static void Remove(this ICodeModule module, IEnumerable <IdentifierReference> targets)
{
foreach (var target in targets.OrderByDescending(e => e.Selection))
{
module.Remove(target);
}
}
/// <summary>
/// Removes a <see cref="Declaration"/> and its <see cref="Declaration.References"/>.
/// </summary>
/// <param name="module">The <see cref="ICodeModule"/> to modify.</param>
/// <param name="target"></param>
public static void Remove(this ICodeModule module, Declaration target)
{
if (!module.Equals(target.QualifiedName.QualifiedModuleName.Component.CodeModule))
{
throw new ArgumentException("Target is not declared in specified module.");
}
var sortedItems = target.References
.Where(reference => module.Equals(reference.QualifiedModuleName.Component.CodeModule))
.Select(reference => Tuple.Create((object)reference, reference.Selection))
.Concat(new[] { Tuple.Create((object)target, target.Selection) })
.OrderByDescending(t => t.Item2);
foreach (var tuple in sortedItems)
{
if (tuple.Item1 is Declaration)
{
RemoveDeclarationOnly(module, target);
}
else
{
var reference = (IdentifierReference)tuple.Item1;
Remove(reference.QualifiedModuleName.Component.CodeModule, reference);
}
}
}
public static void Remove(this ICodeModule module, IdentifierReference target)
{
var parent = (ParserRuleContext)target.Context.Parent;
if (target.IsAssignment)
{
// target is LHS of assignment; need to know if there's a procedure call in RHS
var letStmt = parent as VBAParser.LetStmtContext;
var setStmt = parent as VBAParser.SetStmtContext;
string argList;
if (HasProcedureCall(letStmt, out argList) || HasProcedureCall(setStmt, out argList))
{
// need to remove LHS only; RHS expression may have side-effects
var original = parent.GetText();
var replacement = ReplaceStringAtIndex(original, target.IdentifierName + " = ", string.Empty, 0);
if (argList != null)
{
var atIndex = replacement.IndexOf(argList, StringComparison.OrdinalIgnoreCase);
var plainArgs = " " + argList.Substring(1, argList.Length - 2);
replacement = ReplaceStringAtIndex(replacement, argList, plainArgs, atIndex);
}
module.ReplaceLine(parent.Start.Line, replacement);
return;
}
}
module.Remove(parent.GetSelection(), parent);
}
public AutoCompleteEventArgs(ICodeModule module, char character, bool isControlKeyDown, bool isDeleteKey)
{
Module = module;
IsControlKeyDown = isControlKeyDown;
Character = character;
IsDeleteKey = isDeleteKey;
}
public ModuleState SetTokenStream(ICodeModule module, ITokenStream tokenStream)
{
TokenStream = tokenStream;
var tokenStreamRewriter = new TokenStreamRewriter(tokenStream);
ModuleRewriter = new ModuleRewriter(module, tokenStreamRewriter);
return(this);
}
public AutoCompleteEventArgs(ICodeModule module, KeyPressEventArgs e)
{
Character = e.Character;
CodeModule = module;
CurrentSelection = module.GetQualifiedSelection().Value.Selection;
CurrentLine = module.GetLines(CurrentSelection);
ControlDown = e.ControlDown;
IsDelete = e.IsDelete;
}
public static void InsertLines(this ICodeModule module, int startLine, string[] lines)
{
var lineNumber = startLine;
for (var idx = 0; idx < lines.Length; idx++)
{
module.InsertLines(lineNumber, lines[idx]);
lineNumber++;
}
}
public virtual void RemoveSelection(ICodeModule codeModule, IEnumerable <Selection> selection)
{
foreach (var item in selection.OrderBy(x => - x.StartLine))
{
var start = item.StartLine;
var end = item.EndLine;
var lineCount = end - start + 1;
codeModule.DeleteLines(start, lineCount);
}
}
private static IProjectsProvider TestProvider(QualifiedModuleName module, ICodeModule testModule)
{
var component = new Mock <IVBComponent>();
component.Setup(c => c.CodeModule).Returns(testModule);
var provider = new Mock <IProjectsProvider>();
provider.Setup(p => p.Component(It.IsAny <QualifiedModuleName>()))
.Returns <QualifiedModuleName>(qmn => qmn.Equals(module) ? component.Object : null);
return(provider.Object);
}
private static void RemoveDeclarationOnly(this ICodeModule module, Declaration target)
{
var multipleDeclarations = target.DeclarationType == DeclarationType.Variable && target.HasMultipleDeclarationsInStatement();
var context = GetStmtContext(target);
var declarationText = context.GetText().Replace(" _" + Environment.NewLine, Environment.NewLine);
var selection = GetStmtContextSelection(target);
Debug.Assert(selection.StartColumn > 0);
var oldLines = module.GetLines(selection);
var indent = oldLines.IndexOf(oldLines.FirstOrDefault(c => c != ' ')) + 1;
var newLines = oldLines
.Replace(" _" + Environment.NewLine, Environment.NewLine)
.Remove(selection.StartColumn - 1, declarationText.Length - selection.StartColumn + indent);
if (multipleDeclarations)
{
selection = GetStmtContextSelection(target);
newLines = RemoveExtraComma(module.GetLines(selection).Replace(oldLines, newLines),
target.CountOfDeclarationsInStatement(), target.IndexOfVariableDeclarationInStatement());
}
var newLinesWithoutExcessSpaces = newLines.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
for (var i = 0; i < newLinesWithoutExcessSpaces.Length; i++)
{
newLinesWithoutExcessSpaces[i] = newLinesWithoutExcessSpaces[i].RemoveExtraSpacesLeavingIndentation();
}
for (var i = newLinesWithoutExcessSpaces.Length - 1; i >= 0; i--)
{
if (newLinesWithoutExcessSpaces[i].Trim() == string.Empty)
{
continue;
}
if (newLinesWithoutExcessSpaces[i].EndsWith(" _"))
{
newLinesWithoutExcessSpaces[i] =
newLinesWithoutExcessSpaces[i].Remove(newLinesWithoutExcessSpaces[i].Length - 2);
}
break;
}
// remove all lines with only whitespace
newLinesWithoutExcessSpaces = newLinesWithoutExcessSpaces.Where(str => str.Any(c => !char.IsWhiteSpace(c))).ToArray();
module.DeleteLines(selection);
if (newLinesWithoutExcessSpaces.Any())
{
module.InsertLines(selection.StartLine, string.Join(Environment.NewLine, newLinesWithoutExcessSpaces));
}
}
public ExtractMethodRefactoring(
ICodeModule codeModule,
Action <Object> onParseRequest,
Func <QualifiedSelection?, string, IExtractMethodModel> createMethodModel,
IExtractMethodExtraction extraction)
{
_codeModule = codeModule;
_createMethodModel = createMethodModel;
_extraction = extraction;
_onParseRequest = onParseRequest;
}
public void SubstituteCode(ICodeModule module, CodeString newCode)
{
try
{
module.DeleteLines(newCode.SnippetPosition);
module.InsertLines(newCode.SnippetPosition.StartLine, newCode.Code);
}
catch
{
Debug.Assert(false, "too many line continuations. we shouldn't even be here.");
}
}
private void RewriteCall(VBAParser.ArgumentListContext paramList, ICodeModule module)
{
var argValues = new List <string>();
if (paramList.positionalOrNamedArgumentList().positionalArgumentOrMissing() != null)
{
argValues.AddRange(paramList.positionalOrNamedArgumentList().positionalArgumentOrMissing().Select(p =>
{
if (p is VBAParser.SpecifiedPositionalArgumentContext)
{
return(((VBAParser.SpecifiedPositionalArgumentContext)p).positionalArgument().GetText());
}
return(string.Empty);
}).ToList());
}
if (paramList.positionalOrNamedArgumentList().namedArgumentList() != null)
{
argValues.AddRange(paramList.positionalOrNamedArgumentList().namedArgumentList().namedArgument().Select(p => p.GetText()).ToList());
}
if (paramList.positionalOrNamedArgumentList().requiredPositionalArgument() != null)
{
argValues.Add(paramList.positionalOrNamedArgumentList().requiredPositionalArgument().GetText());
}
var lineCount = paramList.Stop.Line - paramList.Start.Line + 1; // adjust for total line count
var newContent = module.GetLines(paramList.Start.Line, lineCount);
newContent = newContent.Remove(paramList.Start.Column, paramList.GetText().Length);
var reorderedArgValues = new List <string>();
foreach (var param in _model.Parameters)
{
var argAtIndex = argValues.ElementAtOrDefault(param.Index);
if (argAtIndex != null)
{
reorderedArgValues.Add(argAtIndex);
}
}
// property let/set and paramarrays
for (var index = reorderedArgValues.Count; index < argValues.Count; index++)
{
reorderedArgValues.Add(argValues[index]);
}
newContent = newContent.Insert(paramList.Start.Column, string.Join(", ", reorderedArgValues));
module.ReplaceLine(paramList.Start.Line, newContent.Replace(" _" + Environment.NewLine, string.Empty));
module.DeleteLines(paramList.Start.Line + 1, lineCount - 1);
}
private static string GetCode(ICodeModule module)
{
var lines = module.CountOfLines;
if (lines == 0)
{
return(string.Empty);
}
var codeLines = module.GetLines(1, lines);
var code = string.Concat(codeLines);
return(code);
}
public void Apply(ICodeModule codeModule, IExtractMethodModel model, Selection selection)
{
var newMethodCall = model.Method.NewMethodCall();
var positionToInsertNewMethod = model.PositionForNewMethod;
var positionForMethodCall = model.PositionForMethodCall;
var selectionToRemove = model.RowsToRemove;
// The next 4 lines are dependent on the positions of the various parts,
// so have to be applied in the correct order.
var newMethod = ConstructLinesOfProc(codeModule, model);
codeModule.InsertLines(positionToInsertNewMethod.StartLine, newMethod);
RemoveSelection(codeModule, selectionToRemove);
codeModule.InsertLines(selection.StartLine, newMethodCall);
}
private static string[] GetSanitizedCode(ICodeModule module)
{
var lines = module.CountOfLines;
if (lines == 0)
{
return(new string[] { });
}
var code = module.GetLines(1, lines).Replace("\r", string.Empty).Split('\n');
StripLineNumbers(code);
return(code);
}
public static void Remove(this ICodeModule module, Selection selection, ParserRuleContext instruction)
{
var originalCodeLines = module.GetLines(selection.StartLine, selection.LineCount);
var originalInstruction = instruction.GetText();
module.DeleteLines(selection.StartLine, selection.LineCount);
var newCodeLines = originalCodeLines.Replace(originalInstruction, string.Empty);
if (!string.IsNullOrEmpty(newCodeLines))
{
module.InsertLines(selection.StartLine, newCodeLines);
}
}
private IEnumerable <RegexSearchResult> GetResultsFromModule(ICodeModule module, string searchPattern)
{
var results = new List <RegexSearchResult>();
// VBA uses 1-based indexing
for (var i = 1; i <= module.CountOfLines; i++)
{
var codeLine = module.GetLines(i, 1);
var matches = LineMatches(codeLine, searchPattern)
.Select(m => new RegexSearchResult(m, module, i));
results.AddRange(matches);
}
return(results);
}
private string GetSurroundingCode(ICodeModule module, Selection selection)
{
// throws AccessViolationException!
var declarationLines = module.CountOfDeclarationLines;
if (selection.StartLine <= declarationLines)
{
return(module.GetLines(1, declarationLines));
}
var currentProc = module.GetProcOfLine(selection.StartLine);
var procKind = module.GetProcKindOfLine(selection.StartLine);
var procStart = module.GetProcStartLine(currentProc, procKind);
var lineCount = module.GetProcCountLines(currentProc, procKind);
return(module.GetLines(procStart, lineCount));
}
public AutoCompleteEventArgs(ICodeModule module, KeyPressEventArgs e)
{
if (e.Key == Keys.Delete ||
e.Key == Keys.Back ||
e.Key == Keys.Enter ||
e.Key == Keys.Tab)
{
Keys = e.Key;
}
else
{
Character = e.Character;
}
CodeModule = module;
CurrentSelection = module.GetQualifiedSelection().Value.Selection;
CurrentLine = module.GetLines(CurrentSelection);
}
private IEnumerable <RegexSearchResult> GetResultsFromModule(ICodeModule module, string searchPattern, Selection selection)
{
var startLine = selection.StartLine > 1
? selection.StartLine
: 1;
var moduleLines = module.CountOfLines;
var stopLine = selection.EndLine < moduleLines
? selection.EndLine
: moduleLines;
if (startLine > stopLine)
{
return(new List <RegexSearchResult>());
}
if (startLine == stopLine)
{
return(LineMatches(module.GetLines(startLine, 1), selection.StartColumn, null, searchPattern)
.Select(m => new RegexSearchResult(m, module, startLine, selection.StartColumn - 1))
.ToList());
}
var results = new List <RegexSearchResult>();
var firstLineMatches = LineMatches(module.GetLines(startLine, 1), selection.StartColumn, selection.EndColumn, searchPattern)
.Select(m => new RegexSearchResult(m, module, startLine));
results.AddRange(firstLineMatches);
for (var lineIndex = startLine + 1; lineIndex < stopLine; lineIndex++)
{
var codeLine = module.GetLines(lineIndex, 1);
var matches = LineMatches(codeLine, searchPattern)
.Select(m => new RegexSearchResult(m, module, lineIndex));
results.AddRange(matches);
}
var lastLineMatches = LineMatches(module.GetLines(stopLine, 1), 1, selection.EndColumn, searchPattern)
.Select(m => new RegexSearchResult(m, module, stopLine));
results.AddRange(lastLineMatches);
return(results);
}
public CodeString GetCurrentLogicalLine(ICodeModule module)
{
Selection pSelection;
using (var pane = module.CodePane)
{
pSelection = pane.Selection;
}
var selectedContent = module.GetLines(pSelection.StartLine, pSelection.LineCount);
var selectedLines = selectedContent.Replace("\r", string.Empty).Split('\n');
var currentLine = selectedLines[0];
var caretStartLine = (pSelection.StartLine, currentLine);
var lines = new List <(int pLine, string Content)> {
caretStartLine
};
// selection line may not be the only physical line in the complete logical line; accounts for line continuations.
InsertPhysicalLinesAboveSelectionStart(lines, module, pSelection.StartLine);
AppendPhysicalLinesBelowSelectionStart(lines, module, pSelection.StartLine, currentLine);
var logicalLine = string.Join("\r\n", lines.Select(e => e.Content));
var zCaretLine = lines.IndexOf(caretStartLine);
var zCaretColumn = pSelection.StartColumn - 1;
var caretPosition = new Selection(
zCaretLine, zCaretColumn, zCaretLine + pSelection.LineCount - 1, pSelection.EndColumn - 1);
var pStartLine = lines[0].pLine;
var pEndLine = lines[lines.Count - 1].pLine;
var snippetPosition = new Selection(pStartLine, 1, pEndLine, 1);
if (pStartLine > pSelection.StartLine || pEndLine > pSelection.EndLine)
{
// selection spans more than a single logical line
return(null);
}
var result = new CodeString(logicalLine, caretPosition, snippetPosition);
return(result);
}
private void RewriteCall(VBAParser.ArgumentListContext argList, ICodeModule module)
{
var rewriter = _model.State.GetRewriter(module.Parent);
var args = argList.argument().Select((s, i) => new { Index = i, Text = s.GetText() }).ToList();
for (var i = 0; i < _model.Parameters.Count; i++)
{
if (argList.argument().Count <= i)
{
break;
}
var arg = argList.argument()[i];
rewriter.Replace(arg, args.Single(s => s.Index == _model.Parameters[i].Index).Text);
}
_rewriters.Add(rewriter);
}
private void RemoveCallArguments(VBAParser.ArgumentListContext argList, ICodeModule module)
{
var rewriter = _model.State.GetRewriter(module.Parent);
var args = argList.children.OfType <VBAParser.ArgumentContext>().ToList();
for (var i = 0; i < _model.Parameters.Count; i++)
{
if (!_model.Parameters[i].IsRemoved)
{
continue;
}
if (_model.Parameters[i].IsParamArray)
{
var index = i == 0 ? 0 : argList.children.IndexOf(args[i - 1]) + 1;
for (var j = index; j < argList.children.Count; j++)
{
rewriter.Remove((dynamic)argList.children[j]);
}
break;
}
if (args.Count > i && args[i].positionalArgument() != null)
{
rewriter.Remove(args[i]);
}
else
{
var arg = args.Where(a => a.namedArgument() != null)
.SingleOrDefault(a =>
a.namedArgument().unrestrictedIdentifier().GetText() ==
_model.Parameters[i].Declaration.IdentifierName);
if (arg != null)
{
rewriter.Remove(arg);
}
}
}
}
