public static async Task <ConversionResult> ConvertAsync(CodeWithOptions code)
{
if (!IsSupportedSource(code.FromLanguage, code.FromLanguageVersion))
{
return(new ConversionResult(new NotSupportedException($"Source language {code.FromLanguage} {code.FromLanguageVersion} is not supported!")));
}
if (!IsSupportedTarget(code.ToLanguage, code.ToLanguageVersion))
{
return(new ConversionResult(new NotSupportedException($"Target language {code.ToLanguage} {code.ToLanguageVersion} is not supported!")));
}
if (code.FromLanguage == code.ToLanguage && code.FromLanguageVersion != code.ToLanguageVersion)
{
return(new ConversionResult(new NotSupportedException($"Converting from {code.FromLanguage} {code.FromLanguageVersion} to {code.ToLanguage} {code.ToLanguageVersion} is not supported!")));
}
switch (code.FromLanguage)
{
case "C#":
switch (code.ToLanguage)
{
case "Visual Basic":
return(await ProjectConversion.ConvertTextAsync <CSToVBConversion>(code.Text, new TextConversionOptions(code.References)));
}
break;
case "Visual Basic":
switch (code.ToLanguage)
{
case "C#":
return(await ProjectConversion.ConvertTextAsync <VBToCSConversion>(code.Text, new TextConversionOptions(code.References)));
}
break;
}
return(new ConversionResult(new NotSupportedException($"Converting from {code.FromLanguage} {code.FromLanguageVersion} to {code.ToLanguage} {code.ToLanguageVersion} is not supported!")));
}
private async Task <ConversionResult> ConvertTextAsync <TLanguageConversion>(string text,
CancellationToken cancellationToken, string documentPath = null) where TLanguageConversion : ILanguageConversion, new()
{
return(await ProjectConversion.ConvertTextAsync <TLanguageConversion>(text,
await CreateTextConversionOptionsAsync(documentPath),
cancellationToken : cancellationToken,
progress : CreateOutputWindowProgress()));
}
protected async Task <string> ConvertAsync <TLanguageConversion>(string inputCode, TextConversionOptions conversionOptions = default) where TLanguageConversion : ILanguageConversion, new()
{
var textConversionOptions = conversionOptions ?? new TextConversionOptions(DefaultReferences.NetStandard2)
{
RootNamespaceOverride = _rootNamespace, ShowCompilationErrors = true
};
var conversionResult = await ProjectConversion.ConvertTextAsync <TLanguageConversion>(inputCode, textConversionOptions);
return((conversionResult.ConvertedCode ?? "") + (conversionResult.GetExceptionsAsString() ?? ""));
}
private async Task <ConversionResult> ConvertFileTextAsync <TLanguageConversion>(string documentPath, Span selected, CancellationToken cancellationToken)
where TLanguageConversion : ILanguageConversion, new()
{
var documentText = File.ReadAllText(documentPath);
if (selected.Length > 0 && documentText.Length >= selected.End)
{
documentText = documentText.Substring(selected.Start, selected.Length);
}
var convertTextOnly = await ProjectConversion.ConvertTextAsync <TLanguageConversion>(documentText, new TextConversionOptions(DefaultReferences.NetStandard2, documentPath), CreateOutputWindowProgress(), cancellationToken);
convertTextOnly.SourcePathOrNull = documentPath;
return(convertTextOnly);
}
private static IEnumerable <NamedTest> GetSelfVerifyingFacts <TTargetCompiler, TLanguageConversion>(string sourceFileText,
List <NamedTest> runnableTestsInSource) where TTargetCompiler : ICompiler, new()
where TLanguageConversion : ILanguageConversion, new()
{
// Lazy to avoid confusing test runner on error, but also avoid calculating multiple times
var conversionResultAsync = new AsyncLazy <ConversionResult>(() => {
var xUnitReferences = DefaultReferences.With(typeof(FactAttribute).Assembly, typeof(Assert).Assembly);
return(ProjectConversion.ConvertTextAsync <TLanguageConversion>(sourceFileText, new TextConversionOptions(xUnitReferences)));
});
var runnableTestsInTarget = new AsyncLazy <Dictionary <string, NamedTest> >(async() => GetConvertedNamedFacts <TTargetCompiler>(runnableTestsInSource,
await conversionResultAsync.GetValueAsync()));
return(runnableTestsInSource.Select(sourceFact =>
new NamedTest(sourceFact.Name, async() =>
{
try
{
await sourceFact.Execute();
}
catch (TargetInvocationException ex)
{
throw new XunitException(
$"Source test failed, ensure the source is correct for \"{sourceFact.Name}\": {(ex.InnerException ?? ex)}");
}
try {
var test = await runnableTestsInTarget.GetValueAsync();
await test[sourceFact.Name].Execute();
}
catch (TargetInvocationException ex) {
var conversionResult = await conversionResultAsync.GetValueAsync();
throw new XunitException(
$"Converted test failed, the conversion is incorrect for \"{sourceFact.Name}\": {(ex.InnerException ?? ex)}\r\nConverted Code: {conversionResult.ConvertedCode ?? conversionResult.GetExceptionsAsString()}");
}
})
));
}
