Try to use project references to avoid reference conversion

GrahamTheCoder · GrahamTheCoder · commit aca11a21ee43 · 2018-08-18T23:29:07.000+01:00
The previous issue was that copying metadata references directly between compilations wasn't working for `CompilationReference`s.
Originally I thought it was only possible to reference a compilation of the same type, and hence copying references wouldn't work, but now I suspect it just needs an accompanying project reference
diff --git a/ICSharpCode.CodeConverter/CSharp/VBToCSConversion.cs b/ICSharpCode.CodeConverter/CSharp/VBToCSConversion.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using ICSharpCode.CodeConverter.Shared;
 using ICSharpCode.CodeConverter.Util;
+using ICSharpCode.CodeConverter.VB;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Text;
@@ -17,24 +18,21 @@ namespace ICSharpCode.CodeConverter.CSharp
     public class VBToCSConversion : ILanguageConversion
     {
         private Compilation _sourceCompilation;
-        private readonly List<SyntaxTree> _firstPassResults = new List<SyntaxTree>();
         private readonly List<SyntaxTree> _secondPassResults = new List<SyntaxTree>();
-        private Lazy<CSharpCompilation> _targetCompilation;
-        
-        private CSharpCompilation CreateCompilation(List<SyntaxTree> csTrees)
+        private CSharpCompilation _convertedCompilation;
+
+
+        public void Initialize(Compilation convertedCompilation)
         {
-            var references = _sourceCompilation.References.Select(ReferenceConverter.ConvertReference);
-            return CSharpCompilation.Create("Conversion", csTrees, references,
-                new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+            _convertedCompilation = (CSharpCompilation) convertedCompilation;
         }
 
         public SyntaxTree SingleFirstPass(Compilation sourceCompilation, SyntaxTree tree)
         {
             _sourceCompilation = sourceCompilation;
             var converted = VisualBasicConverter.ConvertCompilationTree((VisualBasicCompilation)sourceCompilation, (VisualBasicSyntaxTree)tree);
             var convertedTree = SyntaxFactory.SyntaxTree(converted);
-            _firstPassResults.Add(convertedTree);
-            _targetCompilation = new Lazy<CSharpCompilation>(() => CreateCompilation(_firstPassResults));
+            _convertedCompilation = _convertedCompilation.AddSyntaxTrees(convertedTree);
             return convertedTree;
         }
 
@@ -60,6 +58,8 @@ public SyntaxNode GetSurroundedNode(IEnumerable<SyntaxNode> descendantNodes,
             };
         }
 
+        public string TargetLanguage { get; } = LanguageNames.CSharp;
+
         public bool CanBeContainedByMethod(SyntaxNode node)
         {
             return node is VBSyntax.IncompleteMemberSyntax ||
@@ -116,15 +116,14 @@ public List<SyntaxNode> FindSingleImportantChild(SyntaxNode annotatedNode)
 
         public SyntaxNode SingleSecondPass(KeyValuePair<string, SyntaxTree> cs)
         {
-            var cSharpSyntaxNode = new CompilationErrorFixer(_targetCompilation.Value, (CSharpSyntaxTree)cs.Value).Fix();
+            var cSharpSyntaxNode = new CompilationErrorFixer(_convertedCompilation, (CSharpSyntaxTree)cs.Value).Fix();
             _secondPassResults.Add(cSharpSyntaxNode.SyntaxTree);
             return cSharpSyntaxNode;
         }
 
         public string GetWarningsOrNull()
         {
-            var finalCompilation = CreateCompilation(_firstPassResults);
-            return CompilationWarnings.WarningsForCompilation(_sourceCompilation, "source") + CompilationWarnings.WarningsForCompilation(finalCompilation, "target");
+            return CompilationWarnings.WarningsForCompilation(_sourceCompilation, "source") + CompilationWarnings.WarningsForCompilation(_convertedCompilation, "target");
         }
 
         public SyntaxTree CreateTree(string text)
@@ -133,6 +132,12 @@ public SyntaxTree CreateTree(string text)
         }
 
         public Compilation CreateCompilationFromTree(SyntaxTree tree, IEnumerable<MetadataReference> references)
+        {
+            var compilation = CreateVisualBasicCompilation(references);
+            return compilation.AddSyntaxTrees(tree);
+        }
+
+        public static VisualBasicCompilation CreateVisualBasicCompilation(IEnumerable<MetadataReference> references)
         {
             var compilationOptions = new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary)
                 .WithGlobalImports(GlobalImport.Parse(
@@ -148,7 +153,7 @@ public Compilation CreateCompilationFromTree(SyntaxTree tree, IEnumerable<Metada
                     "System.Text",
                     "System.Threading.Tasks",
                     "Microsoft.VisualBasic"));
-            var compilation = VisualBasicCompilation.Create("Conversion", new[] {tree}, references)
+            var compilation = VisualBasicCompilation.Create("Conversion", references: references)
                 .WithOptions(compilationOptions);
             return compilation;
         }
diff --git a/ICSharpCode.CodeConverter/ILanguageConversion.cs b/ICSharpCode.CodeConverter/ILanguageConversion.cs
@@ -1,4 +1,5 @@
-﻿using System.Collections.Generic;
+﻿using System;
+using System.Collections.Generic;
 using Microsoft.CodeAnalysis;
 
 namespace ICSharpCode.CodeConverter.CSharp
@@ -20,5 +21,7 @@ SyntaxNode GetSurroundedNode(IEnumerable<SyntaxNode> descendantNodes,
             bool surroundedWithMethod);
         IReadOnlyCollection<(string, string)> GetProjectTypeGuidMappings();
         IEnumerable<(string, string)> GetProjectFileReplacementRegexes();
+        string TargetLanguage { get; }
+        void Initialize(Compilation convertedCompilation);
     }
 }
diff --git a/ICSharpCode.CodeConverter/Shared/ProjectConversion.cs b/ICSharpCode.CodeConverter/Shared/ProjectConversion.cs
@@ -6,9 +6,12 @@
 using System.Threading.Tasks;
 using ICSharpCode.CodeConverter.CSharp;
 using ICSharpCode.CodeConverter.Util;
+using ICSharpCode.CodeConverter.VB;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Text;
+using Microsoft.CodeAnalysis.VisualBasic;
 
 namespace ICSharpCode.CodeConverter.Shared
 {
@@ -24,18 +27,19 @@ public class ProjectConversion
         private readonly ILanguageConversion _languageConversion;
         private readonly bool _handlePartialConversion;
 
-        private ProjectConversion(Compilation sourceCompilation, string solutionDir, ILanguageConversion languageConversion)
-            : this(sourceCompilation, sourceCompilation.SyntaxTrees.Where(t => t.FilePath.StartsWith(solutionDir)), languageConversion)
+        private ProjectConversion(Compilation sourceCompilation, string solutionDir, ILanguageConversion languageConversion, Compilation convertedCompilation)
+            : this(sourceCompilation, sourceCompilation.SyntaxTrees.Where(t => t.FilePath.StartsWith(solutionDir)), languageConversion, convertedCompilation)
         {
             _solutionDir = solutionDir;
         }
 
-        private ProjectConversion(Compilation sourceCompilation, IEnumerable<SyntaxTree> syntaxTreesToConvert, ILanguageConversion languageConversion)
+        private ProjectConversion(Compilation sourceCompilation, IEnumerable<SyntaxTree> syntaxTreesToConvert, ILanguageConversion languageConversion, Compilation convertedCompilation)
         {
             _languageConversion = languageConversion;
             this._sourceCompilation = sourceCompilation;
             _syntaxTreesToConvert = syntaxTreesToConvert.ToList();
             _handlePartialConversion = _syntaxTreesToConvert.Count() == 1;
+            languageConversion.Initialize(convertedCompilation.RemoveAllSyntaxTrees());
         }
 
         public static ConversionResult ConvertText<TLanguageConversion>(string text, IReadOnlyCollection<MetadataReference> references) where TLanguageConversion : ILanguageConversion, new()
@@ -54,24 +58,38 @@ public static async Task<ConversionResult> ConvertSingle(Compilation compilation
                 syntaxTree = annotatedSyntaxTree;
             }
 
-            var conversion = new ProjectConversion(compilation, new [] {syntaxTree}, languageConversion);
+            var conversion = new ProjectConversion(compilation, new [] {syntaxTree}, languageConversion, GetConvertedCompilation(compilation, languageConversion));
             var conversionResults = ConvertProjectContents(conversion).ToList();
             var codeResult = conversionResults.SingleOrDefault(x => !string.IsNullOrWhiteSpace(x.ConvertedCode)) 
                              ?? conversionResults.First();
             codeResult.Exceptions = conversionResults.SelectMany(x => x.Exceptions).ToArray();
             return codeResult;
         }
 
+        private static Compilation GetConvertedCompilation(Compilation compilation, ILanguageConversion languageConversion)
+        {
+            return languageConversion is VBToCSConversion ? CSToVBConversion.CreateCSharpCompilation(compilation.References) : (Compilation) VBToCSConversion.CreateVisualBasicCompilation(compilation.References);
+        }
+
         public static IEnumerable<ConversionResult> ConvertProjectContents(Project project,
             ILanguageConversion languageConversion)
         {
             var solutionFilePath = project.Solution.FilePath;
             var solutionDir = Path.GetDirectoryName(solutionFilePath);
             var compilation = project.GetCompilationAsync().GetAwaiter().GetResult();
-            var projectConversion = new ProjectConversion(compilation, solutionDir, languageConversion);
+            var projectConversion = new ProjectConversion(compilation, solutionDir, languageConversion, GetConvertedProjectCompilation(project, languageConversion));
             foreach (var conversionResult in ConvertProjectContents(projectConversion)) yield return conversionResult;
         }
 
+        private static Compilation GetConvertedProjectCompilation(Project project, ILanguageConversion languageConversion)
+        {
+            return project.Solution.RemoveProject(project.Id)
+                .AddProject(project.Id, project.Name, project.AssemblyName, languageConversion.TargetLanguage)
+                .GetProject(project.Id)
+                .WithProjectReferences(project.AllProjectReferences).WithMetadataReferences(project.MetadataReferences)
+                .GetCompilationAsync().GetAwaiter().GetResult();
+        }
+
         private static IEnumerable<ConversionResult> ConvertProjectContents(ProjectConversion projectConversion)
         {
             foreach (var pathNodePair in projectConversion.Convert())
diff --git a/ICSharpCode.CodeConverter/Util/ReferenceConverter.cs b/ICSharpCode.CodeConverter/Util/ReferenceConverter.cs
diff --git a/ICSharpCode.CodeConverter/VB/CSToVBConversion.cs b/ICSharpCode.CodeConverter/VB/CSToVBConversion.cs
@@ -19,22 +19,20 @@ namespace ICSharpCode.CodeConverter.VB
 {
     public class CSToVBConversion : ILanguageConversion
     {
-        private readonly List<SyntaxTree> _firstPassResults = new List<SyntaxTree>();
         private Compilation _sourceCompilation;
+        private VisualBasicCompilation _convertedCompilation;
 
-        private VisualBasicCompilation CreateCompilation(List<SyntaxTree> vbTrees)
+        public void Initialize(Compilation convertedCompilation)
         {
-            var references = _sourceCompilation.References.Select(ReferenceConverter.ConvertReference);
-            return VisualBasicCompilation.Create("Conversion", vbTrees, references,
-                new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+            _convertedCompilation = (VisualBasicCompilation) convertedCompilation;
         }
 
         public SyntaxTree SingleFirstPass(Compilation sourceCompilation, SyntaxTree tree)
         {
             _sourceCompilation = sourceCompilation;
             var converted = CSharpConverter.ConvertCompilationTree((CSharpCompilation)sourceCompilation, (CSharpSyntaxTree)tree);
             var convertedTree = VBSyntaxFactory.SyntaxTree(converted);
-            _firstPassResults.Add(convertedTree);
+            _convertedCompilation = _convertedCompilation.AddSyntaxTrees(convertedTree);
             return convertedTree;
         }
 
@@ -60,6 +58,8 @@ public SyntaxNode GetSurroundedNode(IEnumerable<SyntaxNode> descendantNodes,
             };
         }
 
+        public string TargetLanguage { get; } = LanguageNames.VisualBasic;
+
         public bool CanBeContainedByMethod(SyntaxNode node)
         {
             return node is CSSyntax.IncompleteMemberSyntax || 
@@ -115,8 +115,7 @@ public SyntaxNode SingleSecondPass(KeyValuePair<string, SyntaxTree> cs)
 
         public string GetWarningsOrNull()
         {
-            var finalCompilation = CreateCompilation(_firstPassResults);
-            return CompilationWarnings.WarningsForCompilation(_sourceCompilation, "source") + CompilationWarnings.WarningsForCompilation(finalCompilation, "target");
+            return CompilationWarnings.WarningsForCompilation(_sourceCompilation, "source") + CompilationWarnings.WarningsForCompilation(_convertedCompilation, "target");
         }
 
         public SyntaxTree CreateTree(string text)
@@ -126,7 +125,12 @@ public SyntaxTree CreateTree(string text)
 
         public Compilation CreateCompilationFromTree(SyntaxTree tree, IEnumerable<MetadataReference> references)
         {
-            return CSharpCompilation.Create("Conversion", new[] { tree }, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+            return CreateCSharpCompilation(references).AddSyntaxTrees(tree);
+        }
+
+        public static CSharpCompilation CreateCSharpCompilation(IEnumerable<MetadataReference> references)
+        {
+            return CSharpCompilation.Create("Conversion", references: references, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`		`-using System.Collections.Generic;`
	`1`	`+using System;`
	`2`	`+using System.Collections.Generic;`
`2`	`3`	`using Microsoft.CodeAnalysis;`
`3`	`4`
`4`	`5`	`namespace ICSharpCode.CodeConverter.CSharp`
`@@ -20,5 +21,7 @@ SyntaxNode GetSurroundedNode(IEnumerable<SyntaxNode> descendantNodes,`
`20`	`21`	`bool surroundedWithMethod);`
`21`	`22`	`IReadOnlyCollection<(string, string)> GetProjectTypeGuidMappings();`
`22`	`23`	`IEnumerable<(string, string)> GetProjectFileReplacementRegexes();`
	`24`	`+ string TargetLanguage { get; }`
	`25`	`+ void Initialize(Compilation convertedCompilation);`
`23`	`26`	`}`
`24`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,22 +19,20 @@ namespace ICSharpCode.CodeConverter.VB`
`19`	`19`	`{`
`20`	`20`	`public class CSToVBConversion : ILanguageConversion`
`21`	`21`	`{`
`22`		`- private readonly List<SyntaxTree> _firstPassResults = new List<SyntaxTree>();`
`23`	`22`	`private Compilation _sourceCompilation;`
	`23`	`+ private VisualBasicCompilation _convertedCompilation;`
`24`	`24`
`25`		`- private VisualBasicCompilation CreateCompilation(List<SyntaxTree> vbTrees)`
	`25`	`+ public void Initialize(Compilation convertedCompilation)`
`26`	`26`	`{`
`27`		`- var references = _sourceCompilation.References.Select(ReferenceConverter.ConvertReference);`
`28`		`- return VisualBasicCompilation.Create("Conversion", vbTrees, references,`
`29`		`- new VisualBasicCompilationOptions(OutputKind.DynamicallyLinkedLibrary));`
	`27`	`+ _convertedCompilation = (VisualBasicCompilation) convertedCompilation;`
`30`	`28`	`}`
`31`	`29`
`32`	`30`	`public SyntaxTree SingleFirstPass(Compilation sourceCompilation, SyntaxTree tree)`
`33`	`31`	`{`
`34`	`32`	`_sourceCompilation = sourceCompilation;`
`35`	`33`	`var converted = CSharpConverter.ConvertCompilationTree((CSharpCompilation)sourceCompilation, (CSharpSyntaxTree)tree);`
`36`	`34`	`var convertedTree = VBSyntaxFactory.SyntaxTree(converted);`
`37`		`- _firstPassResults.Add(convertedTree);`
	`35`	`+ _convertedCompilation = _convertedCompilation.AddSyntaxTrees(convertedTree);`
`38`	`36`	`return convertedTree;`
`39`	`37`	`}`
`40`	`38`
`@@ -60,6 +58,8 @@ public SyntaxNode GetSurroundedNode(IEnumerable<SyntaxNode> descendantNodes,`
`60`	`58`	`};`
`61`	`59`	`}`
`62`	`60`
	`61`	`+ public string TargetLanguage { get; } = LanguageNames.VisualBasic;`
	`62`	`+`
`63`	`63`	`public bool CanBeContainedByMethod(SyntaxNode node)`
`64`	`64`	`{`
`65`	`65`	`return node is CSSyntax.IncompleteMemberSyntax \|\|`
`@@ -115,8 +115,7 @@ public SyntaxNode SingleSecondPass(KeyValuePair<string, SyntaxTree> cs)`
`115`	`115`
`116`	`116`	`public string GetWarningsOrNull()`
`117`	`117`	`{`
`118`		`- var finalCompilation = CreateCompilation(_firstPassResults);`
`119`		`- return CompilationWarnings.WarningsForCompilation(_sourceCompilation, "source") + CompilationWarnings.WarningsForCompilation(finalCompilation, "target");`
	`118`	`+ return CompilationWarnings.WarningsForCompilation(_sourceCompilation, "source") + CompilationWarnings.WarningsForCompilation(_convertedCompilation, "target");`
`120`	`119`	`}`
`121`	`120`
`122`	`121`	`public SyntaxTree CreateTree(string text)`
`@@ -126,7 +125,12 @@ public SyntaxTree CreateTree(string text)`
`126`	`125`
`127`	`126`	`public Compilation CreateCompilationFromTree(SyntaxTree tree, IEnumerable<MetadataReference> references)`
`128`	`127`	`{`
`129`		`- return CSharpCompilation.Create("Conversion", new[] { tree }, references, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));`
	`128`	`+ return CreateCSharpCompilation(references).AddSyntaxTrees(tree);`
	`129`	`+ }`
	`130`	`+`
	`131`	`+ public static CSharpCompilation CreateCSharpCompilation(IEnumerable<MetadataReference> references)`
	`132`	`+ {`
	`133`	`+ return CSharpCompilation.Create("Conversion", references: references, options: new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));`
`130`	`134`	`}`
`131`	`135`	`}`
`132`	`136`	`}`