protected static async Task <SyntaxNode> ExtractMethodAsync(
TestWorkspace workspace,
TestHostDocument testDocument,
bool succeed = true,
bool dontPutOutOrRefOnStruct = true,
bool allowBestEffort = false
)
{
var document = workspace.CurrentSolution.GetDocument(testDocument.Id);
Assert.NotNull(document);
var originalOptions = await document.GetOptionsAsync();
var options = originalOptions.WithChangedOption(
ExtractMethodOptions.DontPutOutOrRefOnStruct,
document.Project.Language,
dontPutOutOrRefOnStruct
);
var semanticDocument = await SemanticDocument.CreateAsync(
document,
CancellationToken.None
);
var validator = new CSharpSelectionValidator(
semanticDocument,
testDocument.SelectedSpans.Single(),
options
);
var selectedCode = await validator.GetValidSelectionAsync(CancellationToken.None);
if (!succeed && selectedCode.Status.FailedWithNoBestEffortSuggestion())
{
return(null);
}
Assert.True(selectedCode.ContainsValidContext);
// extract method
var extractor = new CSharpMethodExtractor(
(CSharpSelectionResult)selectedCode,
localFunction: false
);
var result = await extractor.ExtractMethodAsync(CancellationToken.None);
Assert.NotNull(result);
Assert.Equal(
succeed,
result.Succeeded ||
result.SucceededWithSuggestion ||
(allowBestEffort && result.Status.HasBestEffort())
);
var doc = result.Document;
return(doc == null ? null : await doc.GetSyntaxRootAsync());
}
public async static Task Run(MonoDevelop.Ide.Gui.Document doc)
{
if (!doc.Editor.IsSomethingSelected)
{
return;
}
var ad = doc.AnalysisDocument;
if (ad == null || !await IsValid(doc))
{
return;
}
try {
var selectionRange = doc.Editor.SelectionRange;
var token = default(CancellationToken);
var selection = new CSharpSelectionValidator(await SemanticDocument.CreateAsync(ad, token).ConfigureAwait(false), new TextSpan(selectionRange.Offset, selectionRange.Length), doc.GetOptionSet());
var result = await selection.GetValidSelectionAsync(token).ConfigureAwait(false);
if (!result.ContainsValidContext)
{
return;
}
var extractor = new CSharpMethodExtractor((CSharpSelectionResult)result);
var extractionResult = await extractor.ExtractMethodAsync(token).ConfigureAwait(false);
var changes = await extractionResult.Document.GetTextChangesAsync(ad, token);
using (var undo = doc.Editor.OpenUndoGroup()) {
foreach (var change in changes.OrderByDescending(ts => ts.Span.Start))
{
doc.Editor.ReplaceText(change.Span.Start, change.Span.Length, change.NewText);
}
// hack to remove the redundant private modifier.
if (doc.Editor.GetTextAt(extractionResult.MethodDeclarationNode.SpanStart, "private ".Length) == "private ")
{
doc.Editor.RemoveText(extractionResult.MethodDeclarationNode.SpanStart, "private ".Length);
}
}
await doc.UpdateParseDocument();
var info = RefactoringSymbolInfo.GetSymbolInfoAsync(doc, extractionResult.InvocationNameToken.Span.Start).Result;
var sym = info.DeclaredSymbol ?? info.Symbol;
if (sym != null)
{
await new MonoDevelop.Refactoring.Rename.RenameRefactoring().Rename(sym);
}
}
catch (Exception e) {
LoggingService.LogError("Error while extracting method", e);
}
}
protected static async Task <SyntaxNode> ExtractMethodAsync(
TestWorkspace workspace,
TestHostDocument testDocument,
bool succeed = true,
bool dontPutOutOrRefOnStruct = true,
bool allowBestEffort = false)
{
var document = workspace.CurrentSolution.GetDocument(testDocument.Id);
Assert.NotNull(document);
var options = new ExtractMethodGenerationOptions(
ExtractOptions: new ExtractMethodOptions(dontPutOutOrRefOnStruct),
CodeGenerationOptions: CodeGenerationOptions.GetDefault(document.Project.LanguageServices),
AddImportOptions: AddImportPlacementOptions.Default,
NamingPreferences: _ => NamingStylePreferences.Default);
var semanticDocument = await SemanticDocument.CreateAsync(document, CancellationToken.None);
var validator = new CSharpSelectionValidator(semanticDocument, testDocument.SelectedSpans.Single(), options.ExtractOptions, localFunction: false);
var selectedCode = await validator.GetValidSelectionAsync(CancellationToken.None);
if (!succeed && selectedCode.Status.FailedWithNoBestEffortSuggestion())
{
return(null);
}
Assert.True(selectedCode.ContainsValidContext);
// extract method
var extractor = new CSharpMethodExtractor((CSharpSelectionResult)selectedCode, options, localFunction: false);
var result = await extractor.ExtractMethodAsync(CancellationToken.None);
Assert.NotNull(result);
Assert.Equal(succeed,
result.Succeeded ||
result.SucceededWithSuggestion ||
(allowBestEffort && result.Status.HasBestEffort()));
var(doc, _) = await result.GetFormattedDocumentAsync(CodeCleanupOptions.GetDefault(document.Project.LanguageServices), CancellationToken.None);
return(doc == null
? null
: await doc.GetSyntaxRootAsync());
}
protected static SyntaxNode ExtractMethod(
TestWorkspace workspace,
TestHostDocument testDocument,
bool succeed = true,
bool allowMovingDeclaration = true,
bool dontPutOutOrRefOnStruct = true)
{
var document = workspace.CurrentSolution.GetDocument(testDocument.Id);
Assert.NotNull(document);
var options = document.Project.Solution.Workspace.Options
.WithChangedOption(ExtractMethodOptions.AllowMovingDeclaration, document.Project.Language, allowMovingDeclaration)
.WithChangedOption(ExtractMethodOptions.DontPutOutOrRefOnStruct, document.Project.Language, dontPutOutOrRefOnStruct);
var semanticDocument = SemanticDocument.CreateAsync(document, CancellationToken.None).Result;
var validator = new CSharpSelectionValidator(semanticDocument, testDocument.SelectedSpans.Single(), options);
var selectedCode = validator.GetValidSelectionAsync(CancellationToken.None).Result;
if (!succeed && selectedCode.Status.FailedWithNoBestEffortSuggestion())
{
return(null);
}
Assert.True(selectedCode.ContainsValidContext);
// extract method
var extractor = new CSharpMethodExtractor((CSharpSelectionResult)selectedCode);
var result = extractor.ExtractMethodAsync(CancellationToken.None).Result;
Assert.NotNull(result);
Assert.Equal(succeed, result.Succeeded || result.SucceededWithSuggestion);
return((SyntaxNode)result.Document.GetSyntaxRootAsync().Result);
}
