private async IAsyncEnumerable <ConversionResult> ConvertDocumentsUnhandled <TLanguageConversion>(
IReadOnlyCollection <string> documentsPath,
[EnumeratorCancellation] CancellationToken cancellationToken) where TLanguageConversion : ILanguageConversion, new()
{
await _outputWindow.WriteToOutputWindowAsync($"Converting {documentsPath.Count} files...", true, true);
var(documentsWithoutIds, documentsWithIds) = documentsPath
.Select(t => (Path: t, Id: _visualStudioWorkspace.CurrentSolution.GetDocumentIdsWithFilePath(t).FirstOrDefault()))
.SplitOn(t => t.Id != null);
if (documentsWithIds.Any())
{
var documents = documentsWithIds.Select(t => _visualStudioWorkspace.CurrentSolution.GetDocument(t.Id)).ToList();
var convertedDocuments = ProjectConversion.ConvertDocumentsAsync <TLanguageConversion>(documents,
new ConversionOptions {
AbandonOptionalTasksAfter = await GetAbandonOptionalTasksAfterAsync()
}, CreateOutputWindowProgress(), cancellationToken);
await foreach (var convertedDocument in convertedDocuments.WithCancellation(cancellationToken))
{
yield return(convertedDocument);
}
}
if (documentsWithoutIds.Any())
{
await _outputWindow.WriteToOutputWindowAsync("One or more file is not part of a compiling project, using best effort text conversion (less accurate).");
var convertedTexts = documentsWithoutIds.Select(t => ConvertFileTextAsync <TLanguageConversion>(t.Path, Span.FromBounds(0, 0), cancellationToken));
foreach (var convertedText in convertedTexts)
{
yield return(await convertedText);
}
}
}
private static void AssertConvertedCodeResultEquals <TLanguageConversion>(string inputCode, string expectedConvertedCode) where TLanguageConversion : ILanguageConversion, new()
{
var outputNode =
ProjectConversion <TLanguageConversion> .ConvertText(inputCode, CodeWithOptions.DefaultMetadataReferences);
AssertConvertedCodeResultEquals(outputNode, expectedConvertedCode, inputCode);
}
private async Task AssertConvertedCodeResultEquals <TLanguageConversion>(string inputCode, string expectedConvertedCode) where TLanguageConversion : ILanguageConversion, new()
{
var outputNode =
ProjectConversion.ConvertText <TLanguageConversion>(inputCode, DefaultReferences.NetStandard2, _rootNamespace);
AssertConvertedCodeResultEquals(await outputNode, expectedConvertedCode, inputCode);
}
private static IEnumerable <NamedFact> GetSelfVerifyingFacts <TTargetCompiler, TLanguageConversion>(string sourceFileText,
List <NamedFact> runnableTestsInSource) where TTargetCompiler : ICompiler, new()
where TLanguageConversion : ILanguageConversion, new()
{
var conversionResult = ProjectConversion.ConvertText <TLanguageConversion>(sourceFileText, DefaultReferences.NetStandard2);
// Avoid confusing test runner on error, but also avoid calculating multiple times
var runnableTestsInTarget = new Lazy <Dictionary <string, NamedFact> >(() => GetConvertedNamedFacts <TTargetCompiler>(runnableTestsInSource,
conversionResult));
return(runnableTestsInSource.Select(sourceFact =>
new NamedFact(sourceFact.Name, () =>
{
try
{
sourceFact.Execute();
}
catch (TargetInvocationException ex)
{
throw new XunitException(
$"Source test failed, ensure the source is correct for \"{sourceFact.Name}\": {(ex.InnerException ?? ex)}");
}
try
{
runnableTestsInTarget.Value[sourceFact.Name].Execute();
}
catch (TargetInvocationException ex)
{
throw new XunitException(
$"Converted test failed, the conversion is incorrect for \"{sourceFact.Name}\": {(ex.InnerException ?? ex)}\r\nConverted Code: {conversionResult.ConvertedCode ?? conversionResult.GetExceptionsAsString()}");
}
})
));
}
private static void AssertConvertedCodeResultEquals <TLanguageConversion>(string inputCode, string expectedConvertedCode) where TLanguageConversion : ILanguageConversion, new()
{
var outputNode =
ProjectConversion.ConvertText <TLanguageConversion>(inputCode, DefaultReferences.NetStandard2);
AssertConvertedCodeResultEquals(outputNode, expectedConvertedCode, inputCode);
}
public static async Task <ConversionResult> Convert(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.ConvertText <CSToVBConversion>(code.Text, new TextConversionOptions(code.References)));
}
break;
case "Visual Basic":
switch (code.ToLanguage)
{
case "C#":
return(await ProjectConversion.ConvertText <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!")));
}
public void UnsafeStatements()
{
var convertedCode = ProjectConversion.ConvertText <CSToVBConversion>(@"class TestClass
{
void TestMethod()
{
int b;
b = 0;
while (b == 0)
{
if (b == 2)
{
unsafe
{
int ab = 32;
int* p = &ab;
Console.WriteLine(""value of ab is {0}"", *p);
}
}
if (b == 3)
break;
b = 1;
}
}
}", CodeWithOptions.DefaultMetadataReferences).ConvertedCode;
Assert.Contains("CONVERSION ERROR", convertedCode);
Assert.Contains("unsafe", convertedCode);
Assert.Contains("UnsafeStatementSyntax", convertedCode);
Assert.Contains("If b = 2 Then", convertedCode);
Assert.Contains("End If", convertedCode);
}
public void ConvertAllProjectsToCSharp(string solutionFilename)
{
var workspace = MSBuildWorkspace.Create();
var solution = workspace.OpenSolutionAsync(solutionFilename).GetAwaiter().GetResult();
Console.WriteLine(ProjectConversion <VBToCSConversion> .ConvertProjects(solution.Projects.Where(p => p.Language == LanguageNames.VisualBasic).ToArray()).Count());
}
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 static async Task <string> GetConvertedCodeOrErrorString <TLanguageConversion>(string toConvert) where TLanguageConversion : ILanguageConversion, new()
{
var conversionResult = await ProjectConversion.ConvertText <TLanguageConversion>(toConvert, DefaultReferences.NetStandard2);
var convertedCode = conversionResult.ConvertedCode ?? conversionResult.GetExceptionsAsString();
return(convertedCode);
}
public IProject OpenProjectFile(string projectFile)
{
ProjectSerializeData data = null;
IProject currentProject = null;
this.LastErrMsg = string.Empty;
string fileName = Path.GetFileName(projectFile);
try
{
try
{
using (FileStream stream = new FileStream(projectFile, FileMode.Open))
{
BinaryFormatter formatter = new BinaryFormatter();
data = formatter.Deserialize(stream) as ProjectSerializeData;
}
}
catch (SerializationException)
{
ProjectSingleton.Instance.OpenV3R5ProjectFile = true;
data = new ProjectConversion(projectFile).SerializeDataConvert();
}
this.m_PrjSerializeData = data;
ProjectLogicMgr.Instance.CreateProject(this.CfgPath, data.NetType, null);
currentProject = ProjectSingleton.CurrentProject;
ProjectSingleton.CurrentProject.ProjectSerializeData.PrintSeeting = this.m_PrjSerializeData.PrintSeeting;
ProjectSingleton.CurrentProject.ProjectSerializeData.PSCollection = this.m_PrjSerializeData.PSCollection;
MainFormSingleton.CurrentMainForm.ResourceMrgMenuItem.Visible = false;
ProjectInfo projectInfo = new ProjectInfo
{
projectName = fileName,
projectDocument = projectFile,
projectLossPath = this.GetLossPath(projectFile)
};
currentProject.Name = fileName;
currentProject.ProjectIPLFile = projectFile;
(currentProject as GeneralProjectEntity).AllSubSysData = data.AllSubSysData;
currentProject = ProjectDataConvert.Convert(currentProject, data.Version);
this.CreateLossPath(projectInfo.projectLossPath);
this.LockProjectFile(projectInfo);
}
catch (IOException exception)
{
this.LastErrMsg = "The \"" + fileName + "\" had been opened by another application!";
WriteLog.Logger.Error("OpenProjectFile failed!:" + exception.Message);
return(null);
}
catch (Exception exception2)
{
this.LastErrMsg = "Open \"" + fileName + "\" failed!";
WriteLog.Logger.Error("OpenProjectFile failed!:" + exception2.Message);
return(null);
}
return(currentProject);
}
private async Task AssertConvertedCodeResultEquals <TLanguageConversion>(string inputCode, string expectedConvertedCode, TextConversionOptions conversionOptions = default) where TLanguageConversion : ILanguageConversion, new()
{
var textConversionOptions = conversionOptions ?? new TextConversionOptions(DefaultReferences.NetStandard2)
{
RootNamespaceOverride = _rootNamespace
};
var outputNode = ProjectConversion.ConvertText <TLanguageConversion>(inputCode, textConversionOptions);
AssertConvertedCodeResultEquals(await outputNode, expectedConvertedCode, inputCode);
}
private IEnumerable <ConversionResult> ConvertProjectUnhandled <TLanguageConversion>(IReadOnlyCollection <Project> selectedProjects)
where TLanguageConversion : ILanguageConversion, new()
{
var projectsByPath =
_visualStudioWorkspace.CurrentSolution.Projects.ToLookup(p => p.FilePath, p => p);
var projects = selectedProjects.Select(p => projectsByPath[p.FullName].First()).ToList();
var convertedFiles = ProjectConversion <TLanguageConversion> .ConvertProjects(projects);
return(convertedFiles);
}
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 static void TestConversionCSharpToVisualBasicWithoutComments(string csharpCode, string expectedVisualBasicCode)
{
var outputNode = ProjectConversion <CSToVBConversion> .ConvertText(csharpCode, DiagnosticTestBase.DefaultMetadataReferences);
var txt = outputNode.ConvertedCode ?? outputNode.GetExceptionsAsString();
txt = Utils.HomogenizeEol(txt).TrimEnd();
expectedVisualBasicCode = Utils.HomogenizeEol(expectedVisualBasicCode).TrimEnd();
AssertCodeEqual(csharpCode, expectedVisualBasicCode, txt);
}
public void TestConversionVisualBasicToCSharpWithoutComments(string visualBasicCode, string expectedCsharpCode, bool addUsings = true, CSharpParseOptions csharpOptions = null, VisualBasicParseOptions vbOptions = null)
{
if (addUsings)
{
expectedCsharpCode = AddCSUsings(expectedCsharpCode, false);
}
var outputNode = ProjectConversion <VBToCSConversion> .ConvertText(visualBasicCode, DiagnosticTestBase.DefaultMetadataReferences);
var txt = Utils.HomogenizeEol(outputNode.ConvertedCode ?? outputNode.GetExceptionsAsString()).TrimEnd();
expectedCsharpCode = Utils.HomogenizeEol(expectedCsharpCode).TrimEnd();
AssertCodeEqual(visualBasicCode, expectedCsharpCode, txt);
}
private async Task <ConversionResult> ConvertDocumentUnhandledAsync <TLanguageConversion>(string documentPath, Span selected) where TLanguageConversion : ILanguageConversion, new()
{
//TODO Figure out when there are multiple document ids for a single file path
var documentId = _visualStudioWorkspace.CurrentSolution.GetDocumentIdsWithFilePath(documentPath).SingleOrDefault();
if (documentId == null)
{
//If document doesn't belong to any project
return(await ConvertTextOnlyAsync <TLanguageConversion>(documentPath, selected));
}
var document = _visualStudioWorkspace.CurrentSolution.GetDocument(documentId);
var selectedTextSpan = new TextSpan(selected.Start, selected.Length);
return(await ProjectConversion.ConvertSingle(document, selectedTextSpan, new TLanguageConversion()));
}
private static async Task <ConversionResult> ConvertTextOnlyAsync <TLanguageConversion>(string documentPath, Span selected)
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.ConvertText <TLanguageConversion>(documentText, new TextConversionOptions(DefaultReferences.NetStandard2));
convertTextOnly.SourcePathOrNull = documentPath;
return(convertTextOnly);
}
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 ConversionResult ConvertTextOnly <TLanguageConversion>(string documentPath, Span selected)
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 = ProjectConversion <TLanguageConversion> .ConvertText(documentText, CodeWithOptions.DefaultMetadataReferences);
convertTextOnly.SourcePathOrNull = documentPath;
return(convertTextOnly);
}
private async Task <ConversionResult> ConvertDocumentUnhandledAsync <TLanguageConversion>(string documentPath, Span selected, CancellationToken cancellationToken) where TLanguageConversion : ILanguageConversion, new()
{
await _outputWindow.WriteToOutputWindowAsync($"Converting {documentPath}...", true, true);
//TODO Figure out when there are multiple document ids for a single file path
var documentId = _visualStudioWorkspace.CurrentSolution.GetDocumentIdsWithFilePath(documentPath).SingleOrDefault();
if (documentId == null)
{
//If document doesn't belong to any project
return(await ConvertTextOnlyAsync <TLanguageConversion>(documentPath, selected, cancellationToken));
}
var document = _visualStudioWorkspace.CurrentSolution.GetDocument(documentId);
var selectedTextSpan = new TextSpan(selected.Start, selected.Length);
return(await ProjectConversion.ConvertSingle <TLanguageConversion>(document, new SingleConversionOptions { SelectedTextSpan = selectedTextSpan }, CreateOutputWindowProgress(), cancellationToken));
}
private async Task <ConversionResult> ConvertDocumentUnhandledAsync <TLanguageConversion>(string documentPath, Span selected, CancellationToken cancellationToken) where TLanguageConversion : ILanguageConversion, new()
{
await _outputWindow.WriteToOutputWindowAsync($"Converting {documentPath}...", true, true);
// If multiple projects contain this file path, there may be multiple ids, but in that the wrong project may have been built too...
var documentId = _visualStudioWorkspace.CurrentSolution.GetDocumentIdsWithFilePath(documentPath).FirstOrDefault();
if (documentId == null)
{
//If document doesn't belong to any project
await _outputWindow.WriteToOutputWindowAsync("File is not part of a compiling project, using best effort text conversion (less accurate).");
return(await ConvertFileTextAsync <TLanguageConversion>(documentPath, selected, cancellationToken));
}
var document = _visualStudioWorkspace.CurrentSolution.GetDocument(documentId);
var selectedTextSpan = new TextSpan(selected.Start, selected.Length);
return(await ProjectConversion.ConvertSingleAsync <TLanguageConversion>(document, new SingleConversionOptions { SelectedTextSpan = selectedTextSpan, AbandonOptionalTasksAfter = await GetAbandonOptionalTasksAfterAsync() }, CreateOutputWindowProgress(), cancellationToken));
}
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()}");
}
})
));
}
public static async IAsyncEnumerable <ConversionResult> ConvertDocumentsAsync <TLanguageConversion>(
IReadOnlyCollection <Document> documents,
ConversionOptions conversionOptions,
IProgress <ConversionProgress> progress = null,
[EnumeratorCancellation] CancellationToken cancellationToken = default) where TLanguageConversion : ILanguageConversion, new()
{
using var roslynEntryPoint = await RoslynEntryPointAsync(progress ??= new Progress <ConversionProgress>());
var languageConversion = new TLanguageConversion {
ConversionOptions = conversionOptions
};
var project = documents.First().Project;
var projectContentsConverter = await languageConversion.CreateProjectContentsConverterAsync(project, progress, cancellationToken);
documents = documents.Select(doc => projectContentsConverter.SourceProject.GetDocument(doc.Id)).ToList();
var conversion = new ProjectConversion(projectContentsConverter, documents, Enumerable.Empty <TextDocument>(), languageConversion, cancellationToken);
await foreach (var result in conversion.ConvertAsync(progress).WithCancellation(cancellationToken))
{
yield return(result);
}
}
public IProject OpenProjectFile(string projectFile)
{
ProjectSerializeData data = null;
IProject currentProject = null;
this.LastErrMsg = string.Empty;
string fileName = Path.GetFileName(projectFile);
try
{
try
{
using (FileStream stream = new FileStream(projectFile, FileMode.Open))
{
BinaryFormatter formatter = new BinaryFormatter();
data = formatter.Deserialize(stream) as ProjectSerializeData;
}
}
catch (SerializationException)
{
ProjectSingleton.Instance.OpenV3R5ProjectFile = true;
data = new ProjectConversion(projectFile).SerializeDataConvert();
}
this.m_PrjSerializeData = data;
ProjectLogicMgr.Instance.CreateProject(this.CfgPath, data.NetType, null);
currentProject = ProjectSingleton.CurrentProject;
ProjectSingleton.CurrentProject.ProjectSerializeData.PrintSeeting = this.m_PrjSerializeData.PrintSeeting;
ProjectSingleton.CurrentProject.ProjectSerializeData.PSCollection = this.m_PrjSerializeData.PSCollection;
MainFormSingleton.CurrentMainForm.ResourceMrgMenuItem.Visible = true;
ProjectInfo projectInfo = new ProjectInfo();
projectInfo.projectName = fileName;
projectInfo.projectDocument = projectFile;
projectInfo.projectLossPath = this.GetLossPath(projectFile);
currentProject.Name = fileName;
currentProject.ProjectIPLFile = projectFile;
(currentProject as GeneralProjectEntity).AllSubSysData = data.AllSubSysData;
currentProject = ProjectDataConvert.Convert(currentProject, data.Version);
this.CreateLossPath(projectInfo.projectLossPath);
this.LockProjectFile(projectInfo);
}
catch (IOException exception)
{
this.LastErrMsg = "The \"" + fileName + "\" had been opened by another application!";
WriteLog.Logger.Error("OpenProjectFile failed!:" + exception.Message);
return null;
}
catch (Exception exception2)
{
this.LastErrMsg = "Open \"" + fileName + "\" failed!";
WriteLog.Logger.Error("OpenProjectFile failed!:" + exception2.Message);
return null;
}
return currentProject;
}
