private protected static async Task AssertCodeCleanupResult(string expected, string code, CodeStyleOption2 <AddImportPlacement> preferredImportPlacement, bool systemUsingsFirst = true, bool separateUsingGroups = false)
{
using var workspace = TestWorkspace.CreateCSharp(code, composition: EditorTestCompositions.EditorFeaturesWpf);
var solution = workspace.CurrentSolution
.WithOptions(workspace.Options
.WithChangedOption(GenerationOptions.PlaceSystemNamespaceFirst, LanguageNames.CSharp, systemUsingsFirst)
.WithChangedOption(GenerationOptions.SeparateImportDirectiveGroups, LanguageNames.CSharp, separateUsingGroups)
.WithChangedOption(CSharpCodeStyleOptions.PreferredUsingDirectivePlacement, preferredImportPlacement))
.WithAnalyzerReferences(new[]
{
new AnalyzerFileReference(typeof(CSharpCompilerDiagnosticAnalyzer).Assembly.Location, TestAnalyzerAssemblyLoader.LoadFromFile),
new AnalyzerFileReference(typeof(UseExpressionBodyDiagnosticAnalyzer).Assembly.Location, TestAnalyzerAssemblyLoader.LoadFromFile)
});
workspace.TryApplyChanges(solution);
// register this workspace to solution crawler so that analyzer service associate itself with given workspace
var incrementalAnalyzerProvider = workspace.ExportProvider.GetExportedValue <IDiagnosticAnalyzerService>() as IIncrementalAnalyzerProvider;
incrementalAnalyzerProvider.CreateIncrementalAnalyzer(workspace);
var hostdoc = workspace.Documents.Single();
var document = workspace.CurrentSolution.GetDocument(hostdoc.Id);
var codeCleanupService = document.GetLanguageService <ICodeCleanupService>();
var enabledDiagnostics = codeCleanupService.GetAllDiagnostics();
var fallbackOptions = new CodeActionOptions(
CleanupOptions: CodeCleanupOptions.GetDefault(document.Project.LanguageServices) with
{
FormattingOptions = new CSharpSyntaxFormattingOptions(separateImportDirectiveGroups: separateUsingGroups)
});
public async Task CodeCleanersCSharp_Document()
{
var document = CreateDocument("class C { }", LanguageNames.CSharp);
var cleanDocument = await CodeCleaner.CleanupAsync(document, CodeCleanupOptions.GetDefault(document.Project.LanguageServices));
Assert.Equal(document, cleanDocument);
}
public async Task CodeCleanersVisualBasic_Document()
{
var document = CreateDocument(@"Class C
End Class", LanguageNames.VisualBasic);
var cleanDocument = await CodeCleaner.CleanupAsync(document, CodeCleanupOptions.GetDefault(document.Project.LanguageServices));
Assert.Equal(document, cleanDocument);
}
public async Task CodeCleanersCSharp_Annotation()
{
var document = CreateDocument("class C { }", LanguageNames.CSharp);
var annotation = new SyntaxAnnotation();
document = document.WithSyntaxRoot((await document.GetSyntaxRootAsync()).WithAdditionalAnnotations(annotation));
var cleanDocument = await CodeCleaner.CleanupAsync(document, annotation, CodeCleanupOptions.GetDefault(document.Project.LanguageServices));
Assert.Equal(document, cleanDocument);
}
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());
}
public override ValueTask <CleanCodeGenerationOptions> GetCleanCodeGenerationOptionsAsync(HostLanguageServices languageServices, CancellationToken cancellationToken)
{
var lineFormattingOptions = _lineFormattingOptionsProvider.GetLineFormattingOptions();
var codeGenerationOptions = CleanCodeGenerationOptions.GetDefault(languageServices) with
{
CleanupOptions = CodeCleanupOptions.GetDefault(languageServices) with
{
FormattingOptions = SyntaxFormattingOptions.GetDefault(languageServices).With(new LineFormattingOptions
{
IndentationSize = lineFormattingOptions.IndentationSize,
TabSize = lineFormattingOptions.TabSize,
UseTabs = lineFormattingOptions.UseTabs,
NewLine = lineFormattingOptions.NewLine,
})
}
};
return(new ValueTask <CleanCodeGenerationOptions>(codeGenerationOptions));
}
public async Task DontCrash_VB_2()
{
var code = @"
Public Class Class1
Public Custom Event Event2 As EventHandler
AddHandler(ByVal value As EventHandler)
End AddHandler
RemoveHandler(ByVal value As EventHandler)
End RemoveHandler
RaiseEvent(ByVal sender As Object, ByVal e As EventArgs)
e
End Event
End Class
";
var document = CreateDocument(code, LanguageNames.VisualBasic);
var semanticModel = await document.GetSemanticModelAsync();
var root = await document.GetSyntaxRootAsync();
var accessor = root.DescendantNodes().OfType <VisualBasic.Syntax.AccessorBlockSyntax>().Last();
var newSemanticModel = await document.ReuseExistingSpeculativeModelAsync(accessor.Statements[0], CancellationToken.None);
Assert.NotNull(newSemanticModel);
Assert.False(newSemanticModel.IsSpeculativeSemanticModel);
var newDocument = CreateDocument(code, LanguageNames.VisualBasic);
var newRoot = await newDocument.GetSyntaxRootAsync();
var newAccessor = newRoot.DescendantNodes().OfType <VisualBasic.Syntax.AccessorBlockSyntax>().Last();
root = root.ReplaceNode(accessor, newAccessor);
document = document.WithSyntaxRoot(root);
accessor = root.DescendantNodes().OfType <VisualBasic.Syntax.AccessorBlockSyntax>().Last();
newSemanticModel = await document.ReuseExistingSpeculativeModelAsync(accessor.Statements[0], CancellationToken.None);
Assert.NotNull(newSemanticModel);
Assert.True(newSemanticModel.IsSpeculativeSemanticModel);
var cleanDocument = await CodeCleaner.CleanupAsync(document, CodeCleanupOptions.GetDefault(document.Project.LanguageServices));
Assert.Equal(document, cleanDocument);
}
public static async ValueTask <OmniSharpSyntaxFormattingOptionsWrapper> FromDocumentAsync(Document document, OmniSharpLineFormattingOptions fallbackLineFormattingOptions, CancellationToken cancellationToken)
{
var defaultOptions = CodeCleanupOptions.GetDefault(document.Project.LanguageServices);
var fallbackOptions = defaultOptions with
{
FormattingOptions = defaultOptions.FormattingOptions.With(new LineFormattingOptions
{
IndentationSize = fallbackLineFormattingOptions.IndentationSize,
TabSize = fallbackLineFormattingOptions.TabSize,
UseTabs = fallbackLineFormattingOptions.UseTabs,
NewLine = fallbackLineFormattingOptions.NewLine,
})
};
var cleanupOptions = await document.GetCodeCleanupOptionsAsync(fallbackOptions, cancellationToken).ConfigureAwait(false);
return(new OmniSharpSyntaxFormattingOptionsWrapper(cleanupOptions));
}
}
internal async Task TestAsync(string testCode, string expected, OptionsCollection?options = null, ParseOptions?parseOptions = null)
{
using var workspace = CreateTestWorkspace(testCode, parseOptions);
options?.SetGlobalOptions(workspace.GlobalOptions);
var solution = workspace.CurrentSolution;
var document = workspace.CurrentSolution.Projects.First().Documents.First();
var languageServices = document.Project.LanguageServices;
var cleanupOptions =
options?.ToAnalyzerConfigOptions(languageServices).GetCodeCleanupOptions(allowImportsInHiddenRegions: false, fallbackOptions: null, languageServices) ??
CodeCleanupOptions.GetDefault(languageServices);
var formattingService = document.GetRequiredLanguageService <INewDocumentFormattingService>();
var formattedDocument = await formattingService.FormatNewDocumentAsync(document, hintDocument : null, cleanupOptions, CancellationToken.None);
var actual = await formattedDocument.GetTextAsync();
AssertEx.EqualOrDiff(expected, actual.ToString());
}
public void OptionsAreMessagePackSerializable(string language)
{
var messagePackOptions = MessagePackSerializerOptions.Standard.WithResolver(MessagePackFormatters.DefaultResolver);
using var workspace = new AdhocWorkspace();
var languageServices = workspace.Services.GetLanguageServices(language);
var options = new object[]
{
SimplifierOptions.GetDefault(languageServices),
SyntaxFormattingOptions.GetDefault(languageServices),
CodeCleanupOptions.GetDefault(languageServices),
CodeGenerationOptions.GetDefault(languageServices),
IdeCodeStyleOptions.GetDefault(languageServices),
CodeActionOptions.GetDefault(languageServices),
IndentationOptions.GetDefault(languageServices),
ExtractMethodGenerationOptions.GetDefault(languageServices),
// some non-default values:
new VisualBasicIdeCodeStyleOptions(
new IdeCodeStyleOptions.CommonOptions()
{
AllowStatementImmediatelyAfterBlock = new CodeStyleOption2 <bool>(false, NotificationOption2.Error)
},
PreferredModifierOrder: new CodeStyleOption2 <string>("Public Private", NotificationOption2.Error))
};
foreach (var original in options)
{
using var stream = new MemoryStream();
MessagePackSerializer.Serialize(stream, original, messagePackOptions);
stream.Position = 0;
var deserialized = MessagePackSerializer.Deserialize(original.GetType(), stream, messagePackOptions);
Assert.Equal(original, deserialized);
}
}
private static void VerifyRange(string code, ImmutableArray <ICodeCleanupProvider> codeCleanups, ImmutableArray <TextSpan> spans, ref IEnumerable <TextSpan> expectedResult, string language)
{
var result = (IEnumerable <TextSpan>)null;
var spanCodeCleanup = new MockCodeCleanupProvider()
{
CleanupDocumentAsyncImpl = (document, spans, options, cancellationToken) =>
{
result = spans;
return(Task.FromResult(document));
}
};
var document = CreateDocument(code, language);
CodeCleaner.CleanupAsync(document, spans, CodeCleanupOptions.GetDefault(document.Project.LanguageServices), codeCleanups.Concat(spanCodeCleanup)).Wait();
var sortedSpans = result.ToList();
var expectedSpans = expectedResult.ToList();
sortedSpans.Sort();
expectedSpans.Sort();
AssertEx.Equal(expectedSpans, sortedSpans);
}
private static async Task VerifyAsync(string codeWithMarker, string expectedResult, LanguageVersion langVersion = LanguageVersion.VisualBasic14)
{
MarkupTestFile.GetSpans(codeWithMarker,
out var codeWithoutMarker, out ImmutableArray <TextSpan> textSpans);
var document = CreateDocument(codeWithoutMarker, LanguageNames.VisualBasic, langVersion);
var codeCleanups = CodeCleaner.GetDefaultProviders(document).WhereAsArray(p => p.Name is PredefinedCodeCleanupProviderNames.RemoveUnnecessaryLineContinuation or PredefinedCodeCleanupProviderNames.Format);
var cleanDocument = await CodeCleaner.CleanupAsync(document, textSpans[0], CodeCleanupOptions.GetDefault(document.Project.LanguageServices), codeCleanups);
var actualResult = (await cleanDocument.GetSyntaxRootAsync()).ToFullString();
Assert.Equal(expectedResult, actualResult);
}
public async Task CodeCleanersCSharp_Spans()
{
var document = CreateDocument("class C { }", LanguageNames.CSharp);
var root = await document.GetSyntaxRootAsync();
var cleanDocument = await CodeCleaner.CleanupAsync(document, ImmutableArray.Create(root.FullSpan), CodeCleanupOptions.GetDefault(document.Project.LanguageServices));
Assert.Equal(document, cleanDocument);
}
ValueTask <CleanCodeGenerationOptions> OptionsProvider <CleanCodeGenerationOptions> .GetOptionsAsync(HostLanguageServices languageServices, CancellationToken cancellationToken)
{
var codeActionOptions = GetOptions(languageServices);
return(ValueTaskFactory.FromResult(new CleanCodeGenerationOptions(
codeActionOptions.CodeGenerationOptions ?? CodeGenerationOptions.GetDefault(languageServices),
codeActionOptions.CleanupOptions ?? CodeCleanupOptions.GetDefault(languageServices))));
}
ValueTask <CodeCleanupOptions> OptionsProvider <CodeCleanupOptions> .GetOptionsAsync(HostLanguageServices languageServices, CancellationToken cancellationToken) => ValueTaskFactory.FromResult(GetOptions(languageServices).CleanupOptions ?? CodeCleanupOptions.GetDefault(languageServices));
private static async Task VerifyAsync(string codeWithMarker, string expectedResult)
{
codeWithMarker = FixLineEndings(codeWithMarker);
expectedResult = FixLineEndings(expectedResult);
MarkupTestFile.GetSpans(codeWithMarker,
out var codeWithoutMarker, out ImmutableArray <TextSpan> textSpans);
var document = CreateDocument(codeWithoutMarker, LanguageNames.VisualBasic);
var codeCleanups = CodeCleaner.GetDefaultProviders(document).WhereAsArray(p => p.Name is PredefinedCodeCleanupProviderNames.FixIncorrectTokens or PredefinedCodeCleanupProviderNames.Format);
var cleanDocument = await CodeCleaner.CleanupAsync(document, textSpans[0], CodeCleanupOptions.GetDefault(document.Project.LanguageServices), codeCleanups);
Assert.Equal(expectedResult, (await cleanDocument.GetSyntaxRootAsync()).ToFullString());
}