Pull options and projectcontents converter out of language conversion

Tweaks lots of the public API
icsharpcode · Dec 8, 2019 · ef0420e · ef0420e
1 parent 8f23f5f
commit ef0420e
Show file tree

Hide file tree

Showing 17 changed files with 182 additions and 183 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 ## [Unreleased]
 
+* Several C# API tweaks wrapping conversion options into a type
+
 ### Vsix
 
 ### VB -> C#

diff --git a/ICSharpCode.CodeConverter/CSharp/VBToCSConversion.cs b/ICSharpCode.CodeConverter/CSharp/VBToCSConversion.cs
@@ -14,6 +14,9 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Operations;
 using Microsoft.CodeAnalysis.Simplification;
+using Microsoft.CodeAnalysis.VisualBasic;
+using Conversion = Microsoft.CodeAnalysis.CSharp.Conversion;
+using ISymbolExtensions = ICSharpCode.CodeConverter.Util.ISymbolExtensions;
 using LanguageVersion = Microsoft.CodeAnalysis.CSharp.LanguageVersion;
 
 namespace ICSharpCode.CodeConverter.CSharp
@@ -25,35 +28,15 @@ public class VBToCSConversion : ILanguageConversion
     {
         private const string UnresolvedNamespaceDiagnosticId = "CS0246";
 
-        private string _overriddenRootNamespace;
         private VBToCSProjectContentsConverter _vbToCsProjectContentsConverter;
+        public ConversionOptions ConversionOptions { get; set; }
 
-        public async Task<Project> InitializeSource(Project project)
-        {
-            _vbToCsProjectContentsConverter = new VBToCSProjectContentsConverter(_overriddenRootNamespace);
-            return await _vbToCsProjectContentsConverter.InitializeSource(project);
-        }
 
-        public Document CreateProjectDocumentFromTree(Workspace workspace, SyntaxTree tree,
-            IEnumerable<MetadataReference> references)
+        public async Task<IProjectContentsConverter> CreateProjectContentsConverter(Project project)
         {
-            return _vbToCsProjectContentsConverter.CreateProjectDocumentFromTree(workspace, tree, references);
-        }
-
-        public async Task<SyntaxNode> SingleFirstPass(Document document)
-        {
-            return await _vbToCsProjectContentsConverter.SingleFirstPass(document);
-        }
-
-        public async Task<(Project project, List<(string Path, DocumentId DocId, string[] Errors)> firstPassDocIds)>
-            GetConvertedProject((string Path, SyntaxNode Node, string[] Errors)[] firstPassResults)
-        {
-            return await _vbToCsProjectContentsConverter.GetConvertedProject(firstPassResults);
-        }
-
-        public string RootNamespace {
-            get => _vbToCsProjectContentsConverter.RootNamespace;
-            set => _overriddenRootNamespace = value;
+            _vbToCsProjectContentsConverter = new VBToCSProjectContentsConverter(ConversionOptions);
+            await _vbToCsProjectContentsConverter.InitializeSourceAsync(project);
+            return _vbToCsProjectContentsConverter;
         }
 
         public SyntaxNode GetSurroundedNode(IEnumerable<SyntaxNode> descendantNodes,
@@ -170,8 +153,15 @@ public SyntaxTree CreateTree(string text)
 
         private VisualBasicCompiler CreateCompiler()
         {
-            return new VisualBasicCompiler(RootNamespace);
+            return new VisualBasicCompiler(ConversionOptions.RootNamespaceOverride);
+        }
+
+        public Document CreateProjectDocumentFromTree(Workspace workspace, SyntaxTree tree,
+            IEnumerable<MetadataReference> references)
+        {
+            return VisualBasicCompiler.CreateCompilationOptions(ConversionOptions.RootNamespaceOverride)
+                .CreateProjectDocumentFromTree(workspace, tree, references, VisualBasicParseOptions.Default,
+                    ISymbolExtensions.ForcePartialTypesAssemblyName);
         }
-        string ILanguageConversion.LanguageVersion { get { return LanguageVersion.Default.ToDisplayString(); } }
     }
 }
diff --git a/ICSharpCode.CodeConverter/CSharp/VBToCSProjectContentsConverter.cs b/ICSharpCode.CodeConverter/CSharp/VBToCSProjectContentsConverter.cs
@@ -2,6 +2,7 @@
 using System.Threading.Tasks;
 using ICSharpCode.CodeConverter.Shared;
 using ICSharpCode.CodeConverter.Util;
+using ICSharpCode.CodeConverter.VB;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.VisualBasic;
@@ -13,10 +14,9 @@ namespace ICSharpCode.CodeConverter.CSharp
     /// <remarks>
     /// Can be stateful, need a new one for each project
     /// </remarks>
-    internal class VBToCSProjectContentsConverter
+    internal class VBToCSProjectContentsConverter : IProjectContentsConverter
     {
-        private readonly string _overrideRootNamespace;
-        private Project _sourceVbProject;
+        private readonly ConversionOptions _conversionOptions;
         private CSharpCompilation _csharpViewOfVbSymbols;
         private Project _convertedCsProject;
 
@@ -30,25 +30,26 @@ internal class VBToCSProjectContentsConverter
 
         private Project _csharpReferenceProject;
 
-        public VBToCSProjectContentsConverter(string overrideRootNamespace)
+        public VBToCSProjectContentsConverter(ConversionOptions conversionOptions)
         {
-            _overrideRootNamespace = overrideRootNamespace;
+            _conversionOptions = conversionOptions;
         }
 
-        public string RootNamespace => _overrideRootNamespace;
+        public string RootNamespace => _conversionOptions.RootNamespaceOverride;
 
-        public async Task<Project> InitializeSource(Project project)
+        public async Task InitializeSourceAsync(Project project)
         {
             var cSharpCompilationOptions = CSharpCompiler.CreateCompilationOptions();
             _convertedCsProject = project.ToProjectFromAnyOptions(cSharpCompilationOptions, DoNotAllowImplicitDefault);
             _csharpReferenceProject = project.CreateReferenceOnlyProjectFromAnyOptions(cSharpCompilationOptions);
             _csharpViewOfVbSymbols = (CSharpCompilation) await _csharpReferenceProject.GetCompilationAsync();
-
-            project = await project.WithRenamedMergedMyNamespace();
-            _sourceVbProject = project;
-            return project;
+            Project = await project.WithRenamedMergedMyNamespace();
         }
 
+        string IProjectContentsConverter.LanguageVersion { get { return LanguageVersion.Default.ToDisplayString(); } }
+
+        public Project Project { get; private set; }
+
         public async Task<SyntaxNode> SingleFirstPass(Document document)
         {
             return await VisualBasicConverter.ConvertCompilationTree(document, _csharpViewOfVbSymbols, _csharpReferenceProject);
@@ -60,13 +61,5 @@ public async Task<SyntaxNode> SingleFirstPass(Document document)
             var (project, docIds) = _convertedCsProject.WithDocuments(firstPassResults);
             return (await project.RenameMergedNamespaces(), docIds);
         }
-
-        public Document CreateProjectDocumentFromTree(Workspace workspace, SyntaxTree tree,
-            IEnumerable<MetadataReference> references)
-        {
-            return VisualBasicCompiler.CreateCompilationOptions(_overrideRootNamespace)
-                .CreateProjectDocumentFromTree(workspace, tree, references, VisualBasicParseOptions.Default,
-                    ISymbolExtensions.ForcePartialTypesAssemblyName);
-        }
     }
 }
diff --git a/ICSharpCode.CodeConverter/CodeConverter.cs b/ICSharpCode.CodeConverter/CodeConverter.cs
@@ -21,13 +21,13 @@ public static async Task<ConversionResult> Convert(CodeWithOptions code)
                 case "C#":
                     switch (code.ToLanguage) {
                         case "Visual Basic":
-                            return await ProjectConversion.ConvertText<CSToVBConversion>(code.Text, code.References);
+                            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, code.References);
+                            return await ProjectConversion.ConvertText<VBToCSConversion>(code.Text, new TextConversionOptions(code.References));
                     }
                     break;
 

diff --git a/ICSharpCode.CodeConverter/ILanguageConversion.cs b/ICSharpCode.CodeConverter/ILanguageConversion.cs
@@ -1,17 +1,14 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Threading.Tasks;
+using ICSharpCode.CodeConverter.Shared;
 using Microsoft.CodeAnalysis;
 
-namespace ICSharpCode.CodeConverter.CSharp
+namespace ICSharpCode.CodeConverter
 {
     public interface ILanguageConversion
     {
-        Task<SyntaxNode> SingleFirstPass(Document document);
         Task<Document> SingleSecondPass(Document doc);
         SyntaxTree CreateTree(string text);
-        Document CreateProjectDocumentFromTree(Workspace workspace, SyntaxTree tree,
-            IEnumerable<MetadataReference> references);
         List<SyntaxNode> FindSingleImportantChild(SyntaxNode annotatedNode);
         bool CanBeContainedByMethod(SyntaxNode node);
         bool MustBeContainedByClass(SyntaxNode node);
@@ -23,11 +20,12 @@ SyntaxNode GetSurroundedNode(IEnumerable<SyntaxNode> descendantNodes,
         IReadOnlyCollection<(string, string)> GetProjectTypeGuidMappings();
         IEnumerable<(string, string)> GetProjectFileReplacementRegexes();
         string TargetLanguage { get; }
-        string RootNamespace { get; set; }
-        string LanguageVersion { get; }
-        Task<Project> InitializeSource(Project project);
+        ConversionOptions ConversionOptions { get; set; }
+
+        Task<IProjectContentsConverter> CreateProjectContentsConverter(Project project);
         string PostTransformProjectFile(string xml);
-        Task<(Project project, List<(string Path, DocumentId DocId, string[] Errors)> firstPassDocIds)>
-            GetConvertedProject((string Path, SyntaxNode Node, string[] Errors)[] firstPassResults);
+
+        Document CreateProjectDocumentFromTree(Workspace workspace, SyntaxTree tree,
+            IEnumerable<MetadataReference> references);
     }
 }
diff --git a/ICSharpCode.CodeConverter/Shared/ConversionOptions.cs b/ICSharpCode.CodeConverter/Shared/ConversionOptions.cs
@@ -0,0 +1,10 @@
+using Microsoft.CodeAnalysis;
+
+namespace ICSharpCode.CodeConverter.Shared
+{
+    public class ConversionOptions
+    {
+        public string RootNamespaceOverride { get; set; }
+        public CompilationOptions TargetCompilationOptionsOverride { get; set; }
+    }
+}
diff --git a/ICSharpCode.CodeConverter/Shared/IProjectContentsConverter.cs b/ICSharpCode.CodeConverter/Shared/IProjectContentsConverter.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis;
+
+namespace ICSharpCode.CodeConverter.Shared
+{
+    public interface IProjectContentsConverter
+    {
+        Task InitializeSourceAsync(Project project);
+        string LanguageVersion { get; }
+        string RootNamespace { get; }
+        Project Project { get; }
+        Task<SyntaxNode> SingleFirstPass(Document document);
+
+        Task<(Project project, List<(string Path, DocumentId DocId, string[] Errors)> firstPassDocIds)>
+            GetConvertedProject((string Path, SyntaxNode Node, string[] Errors)[] firstPassResults);
+    }
+}