/// <summary>
/// Generates formatted source code containing general information about the symbol's
/// containing assembly, and the public, protected, and protected-or-internal interface of
/// which the given ISymbol is or is a part of into the given document
/// </summary>
/// <param name="document">The document to generate source into</param>
/// <param name="symbolCompilation">The <see cref="Compilation"/> in which <paramref name="symbol"/> is resolved.</param>
/// <param name="symbol">The symbol to generate source for</param>
/// <param name="formattingOptions">Options to use to format the document.</param>
/// <param name="cancellationToken">To cancel document operations</param>
/// <returns>The updated document</returns>
public static Task <Document> AddSourceToAsync(Document document, Compilation symbolCompilation, ISymbol symbol, OmniSharpSyntaxFormattingOptionsWrapper formattingOptions, CancellationToken cancellationToken)
{
var service = document.GetRequiredLanguageService <IMetadataAsSourceService>();
var options = new CleanCodeGenerationOptions(
GenerationOptions: CodeGenerationOptions.GetDefault(document.Project.LanguageServices),
CleanupOptions: formattingOptions.CleanupOptions);
return(service.AddSourceToAsync(document, symbolCompilation, symbol, options, cancellationToken));
}
public static async Task <Document> AddSourceToAsync(Document document, Compilation symbolCompilation, ISymbol symbol, CancellationToken cancellationToken)
{
var service = document.GetRequiredLanguageService <IMetadataAsSourceService>();
var cleanupOptions = await document.GetCodeCleanupOptionsAsync(fallbackOptions : null, cancellationToken).ConfigureAwait(false);
var options = new CleanCodeGenerationOptions(
GenerationOptions: CodeGenerationOptions.GetDefault(document.Project.LanguageServices),
CleanupOptions: cleanupOptions);
return(await service.AddSourceToAsync(document, symbolCompilation, symbol, options, cancellationToken).ConfigureAwait(false));
}
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 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);
}
}
ValueTask <CodeAndImportGenerationOptions> OptionsProvider <CodeAndImportGenerationOptions> .GetOptionsAsync(HostLanguageServices languageServices, CancellationToken cancellationToken)
{
var codeActionOptions = GetOptions(languageServices);
return(ValueTaskFactory.FromResult(new CodeAndImportGenerationOptions(
codeActionOptions.CodeGenerationOptions ?? CodeGenerationOptions.GetDefault(languageServices),
codeActionOptions.CleanupOptions?.AddImportOptions ?? AddImportPlacementOptions.Default)));
}
ValueTask <CodeGenerationOptions> OptionsProvider <CodeGenerationOptions> .GetOptionsAsync(HostLanguageServices languageServices, CancellationToken cancellationToken) => ValueTaskFactory.FromResult(GetOptions(languageServices).CodeGenerationOptions ?? CodeGenerationOptions.GetDefault(languageServices));
