Make in process components internal

src/VisualStudio/TestUtilities/InProcess/CSharpInteractiveWindow_InProc.cs

@@ -5,7 +5,7 @@
 
 namespace Roslyn.VisualStudio.Test.Utilities.InProcess
 {
-    public class CSharpInteractiveWindow_InProc : InteractiveWindow_InProc
+    internal class CSharpInteractiveWindow_InProc : InteractiveWindow_InProc
     {
         private const string ViewCommand = "View.C#Interactive";
         private const string WindowTitle = "C# Interactive";

src/VisualStudio/TestUtilities/InProcess/Editor_InProc.cs

@@ -12,7 +12,7 @@
 
 namespace Roslyn.VisualStudio.Test.Utilities.InProcess
 {
-    public class Editor_InProc : InProcComponent
+    internal class Editor_InProc : InProcComponent
     {
         private static readonly Guid IWpfTextViewId = new Guid("8C40265E-9FDB-4F54-A0FD-EBB72B7D0476");
 

src/VisualStudio/TestUtilities/InProcess/InProcComponent.cs

@@ -14,7 +14,7 @@ namespace Roslyn.VisualStudio.Test.Utilities.InProcess
     /// Base class for all components that run inside of the Visual Studio process. Every in-proc component
     /// must provide a public, static, parameterless "Create" method.
     /// </summary>
-    public abstract class InProcComponent : MarshalByRefObject
+    internal abstract class InProcComponent : MarshalByRefObject
     {
         protected InProcComponent() { }
 

src/VisualStudio/TestUtilities/InProcess/InteractiveWindow_InProc.cs

@@ -12,7 +12,7 @@ namespace Roslyn.VisualStudio.Test.Utilities.InProcess
     /// <remarks>
     /// This object exists in the Visual Studio host and is marhsalled across the process boundary.
     /// </remarks>
-    public abstract class InteractiveWindow_InProc : InProcComponent
+    internal abstract class InteractiveWindow_InProc : InProcComponent
     {
         private const string ResetCommand = "InteractiveConsole.Reset";
         private const string ReplSubmissionText = ". ";

src/VisualStudio/TestUtilities/InProcess/SolutionExplorer_InProc.cs

@@ -7,7 +7,7 @@
 
 namespace Roslyn.VisualStudio.Test.Utilities.InProcess
 {
-    public class SolutionExplorer_InProc : InProcComponent
+    internal class SolutionExplorer_InProc : InProcComponent
     {
         private EnvDTE80.Solution2 _solution;
         private string _fileName;

src/VisualStudio/TestUtilities/InProcess/VisualStudioWorkspace_InProc.cs

@@ -13,7 +13,7 @@
 
 namespace Roslyn.VisualStudio.Test.Utilities.InProcess
 {
-    public class VisualStudioWorkspace_InProc : InProcComponent
+    internal class VisualStudioWorkspace_InProc : InProcComponent
     {
         private static readonly Guid RoslynPackageId = new Guid("6cf2e545-6109-4730-8883-cf43d7aec3e1");
         private readonly VisualStudioWorkspace _visualStudioWorkspace;

src/VisualStudio/TestUtilities/InProcess/VisualStudio_InProc.cs

@@ -3,7 +3,7 @@
 
 namespace Roslyn.VisualStudio.Test.Utilities.InProcess
 {
-    public class VisualStudio_InProc : InProcComponent
+    internal class VisualStudio_InProc : InProcComponent
     {
         private VisualStudio_InProc() { }
 

src/VisualStudio/TestUtilities/OutOfProcess/CSharpInteractiveWindow_OutOfProc.cs

@@ -4,11 +4,16 @@
 
 namespace Roslyn.VisualStudio.Test.Utilities.OutOfProcess
 {
-    public class CSharpInteractiveWindow_OutOfProc : InteractiveWindow_OutOfProc<CSharpInteractiveWindow_InProc>
+    public class CSharpInteractiveWindow_OutOfProc : InteractiveWindow_OutOfProc
     {
         public CSharpInteractiveWindow_OutOfProc(VisualStudioInstance visualStudioInstance)
             : base(visualStudioInstance)
         {
         }
+
+        internal override InteractiveWindow_InProc CreateInProcComponent(VisualStudioInstance visualStudioInstance)
+        {
+            return CreateInProcComponent<CSharpInteractiveWindow_InProc>(visualStudioInstance);
+        }
     }
 }

src/VisualStudio/TestUtilities/OutOfProcess/Editor_OutOfProc.cs

@@ -10,33 +10,36 @@ namespace Roslyn.VisualStudio.Test.Utilities.OutOfProcess
     /// <summary>
     /// Provides a means of interacting with the Visual Studio editor by remoting calls into Visual Studio.
     /// </summary>
-    public partial class Editor_OutOfProc : OutOfProcComponent<Editor_InProc>
+    public partial class Editor_OutOfProc : OutOfProcComponent
     {
+        private readonly Editor_InProc _inProc;
+
         internal Editor_OutOfProc(VisualStudioInstance visualStudioInstance)
             : base(visualStudioInstance)
         {
+            this._inProc = CreateInProcComponent<Editor_InProc>(visualStudioInstance);
         }
 
-        public void Activate() => InProc.Activate();
+        public void Activate() => _inProc.Activate();
 
-        public string GetText() => InProc.GetText();
-        public void SetText(string value) => InProc.SetText(value);
+        public string GetText() => _inProc.GetText();
+        public void SetText(string value) => _inProc.SetText(value);
 
-        public string GetCurrentLineText() => InProc.GetCurrentLineText();
-        public int GetCaretPosition() => InProc.GetCaretPosition();
-        public string GetLineTextBeforeCaret() => InProc.GetLineTextBeforeCaret();
-        public string GetLineTextAfterCaret() => InProc.GetLineTextAfterCaret();
+        public string GetCurrentLineText() => _inProc.GetCurrentLineText();
+        public int GetCaretPosition() => _inProc.GetCaretPosition();
+        public string GetLineTextBeforeCaret() => _inProc.GetLineTextBeforeCaret();
+        public string GetLineTextAfterCaret() => _inProc.GetLineTextAfterCaret();
 
-        public void MoveCaret(int position) => InProc.MoveCaret(position);
+        public void MoveCaret(int position) => _inProc.MoveCaret(position);
 
-        public string[] GetCompletionItems() => InProc.GetCompletionItems();
-        public string GetCurrentCompletionItem() => InProc.GetCurrentCompletionItem();
-        public bool IsCompletionActive() => InProc.IsCompletionActive();
+        public string[] GetCompletionItems() => _inProc.GetCompletionItems();
+        public string GetCurrentCompletionItem() => _inProc.GetCurrentCompletionItem();
+        public bool IsCompletionActive() => _inProc.IsCompletionActive();
 
-        public Signature[] GetSignatures() => InProc.GetSignatures();
-        public Signature GetCurrentSignature() => InProc.GetCurrentSignature();
+        public Signature[] GetSignatures() => _inProc.GetSignatures();
+        public Signature GetCurrentSignature() => _inProc.GetCurrentSignature();
 
-        public bool IsCaretOnScreen() => InProc.IsCaretOnScreen();
+        public bool IsCaretOnScreen() => _inProc.IsCaretOnScreen();
 
         public void SendKeys(params object[] keys)
         {

src/VisualStudio/TestUtilities/OutOfProcess/InteractiveWindow_OutOfProc.cs

@@ -7,17 +7,21 @@ namespace Roslyn.VisualStudio.Test.Utilities.OutOfProcess
     /// <summary>
     /// Provides a means of interacting with the interactive window in the Visual Studio host.
     /// </summary>
-    public abstract class InteractiveWindow_OutOfProc<TInProcComponent> : OutOfProcComponent<TInProcComponent>
-        where TInProcComponent : InteractiveWindow_InProc
+    public abstract class InteractiveWindow_OutOfProc : OutOfProcComponent
     {
+        private readonly InteractiveWindow_InProc _inProc;
+
         internal InteractiveWindow_OutOfProc(VisualStudioInstance visualStudioInstance)
             : base (visualStudioInstance)
         {
+            _inProc = CreateInProcComponent(visualStudioInstance);
         }
 
+        internal abstract InteractiveWindow_InProc CreateInProcComponent(VisualStudioInstance visualStudioInstance);
+
         public void Initialize()
         {
-            InProc.Initialize();
+            _inProc.Initialize();
         }
 
         /// <summary>
@@ -25,12 +29,12 @@ public void Initialize()
         /// </summary>
         public string GetLastReplOutput()
         {
-            return InProc.GetLastReplOutput();
+            return _inProc.GetLastReplOutput();
         }
 
         public string GetReplText()
         {
-            return InProc.GetReplText();
+            return _inProc.GetReplText();
         }
 
         /// <summary>
@@ -38,32 +42,32 @@ public string GetReplText()
         /// </summary>
         public string GetReplTextWithoutPrompt()
         {
-            return InProc.GetReplTextWithoutPrompt();
+            return _inProc.GetReplTextWithoutPrompt();
         }
 
         public void ShowWindow(bool waitForPrompt = true)
         {
-            InProc.ShowWindow(waitForPrompt);
+            _inProc.ShowWindow(waitForPrompt);
         }
 
         public void Reset(bool waitForPrompt = true)
         {
-            InProc.Reset(waitForPrompt);
+            _inProc.Reset(waitForPrompt);
         }
 
         public void SubmitText(string text, bool waitForPrompt = true)
         {
-            InProc.SubmitText(text, waitForPrompt);
+            _inProc.SubmitText(text, waitForPrompt);
         }
 
         public void WaitForReplOutput(string outputText)
         {
-            InProc.WaitForReplOutput(outputText);
+            _inProc.WaitForReplOutput(outputText);
         }
 
         public void CleanUpInteractiveWindow()
         {
-            InProc.CloseWindow();
+            _inProc.CloseWindow();
         }
     }
 }

src/VisualStudio/TestUtilities/OutOfProcess/OutOfProcComponent.cs

@@ -7,23 +7,20 @@ namespace Roslyn.VisualStudio.Test.Utilities.OutOfProcess
     /// <summary>
     /// Base class for all components that run outside of the Visual Studio process.
     /// </summary>
-    public abstract class OutOfProcComponent<TInProcComponent>
-        where TInProcComponent : InProcComponent
+    public abstract class OutOfProcComponent
     {
         protected readonly VisualStudioInstance VisualStudioInstance;
-        protected readonly TInProcComponent InProc;
 
         protected OutOfProcComponent(VisualStudioInstance visualStudioInstance)
         {
             VisualStudioInstance = visualStudioInstance;
-
-            InProc = CreateInProcComponent();
         }
 
-        private TInProcComponent CreateInProcComponent()
+        internal static TInProcComponent CreateInProcComponent<TInProcComponent>(VisualStudioInstance visualStudioInstance)
+            where TInProcComponent : InProcComponent
         {
             // Create MarshalByRefObject that can be used to execute code in the VS process.
-            return VisualStudioInstance.ExecuteInHostProcess<TInProcComponent>(
+            return visualStudioInstance.ExecuteInHostProcess<TInProcComponent>(
                 type: typeof(TInProcComponent),
                 methodName: "Create");
         }

src/VisualStudio/TestUtilities/OutOfProcess/SolutionExplorer_OutOfProc.cs

@@ -4,36 +4,42 @@
 
 namespace Roslyn.VisualStudio.Test.Utilities.OutOfProcess
 {
-    public class SolutionExplorer_OutOfProc : OutOfProcComponent<SolutionExplorer_InProc>
+    public class SolutionExplorer_OutOfProc : OutOfProcComponent
     {
+        private readonly SolutionExplorer_InProc _inProc;
+
         public SolutionExplorer_OutOfProc(VisualStudioInstance visualStudioInstance)
             : base(visualStudioInstance)
         {
+            this._inProc = CreateInProcComponent<SolutionExplorer_InProc>(visualStudioInstance);
         }
 
-        public void CloseSolution(bool saveFirst = false) => InProc.CloseSolution(saveFirst);
+        public void CloseSolution(bool saveFirst = false)
+        {
+            _inProc.CloseSolution(saveFirst);
+        }
 
         /// <summary>
         /// Creates and loads a new solution in the host process, optionally saving the existing solution if one exists.
         /// </summary>
         public void CreateSolution(string solutionName, bool saveExistingSolutionIfExists = false)
         {
-            InProc.CreateSolution(solutionName, saveExistingSolutionIfExists);
+            _inProc.CreateSolution(solutionName, saveExistingSolutionIfExists);
         }
 
         public void OpenSolution(string path, bool saveExistingSolutionIfExists = false)
         {
-            InProc.OpenSolution(path, saveExistingSolutionIfExists);
+            _inProc.OpenSolution(path, saveExistingSolutionIfExists);
         }
 
         public void AddProject(string projectName, string projectTemplate, string languageName)
         {
-            InProc.AddProject(projectName, projectTemplate, languageName);
+            _inProc.AddProject(projectName, projectTemplate, languageName);
         }
 
         public void CleanUpOpenSolution()
         {
-            InProc.CleanUpOpenSolution();
+            _inProc.CleanUpOpenSolution();
         }
     }
 }

src/VisualStudio/TestUtilities/OutOfProcess/VisualStudioWorkspace_OutOfProc.cs

@@ -4,54 +4,57 @@
 
 namespace Roslyn.VisualStudio.Test.Utilities.OutOfProcess
 {
-    public class VisualStudioWorkspace_OutOfProc : OutOfProcComponent<VisualStudioWorkspace_InProc>
+    public class VisualStudioWorkspace_OutOfProc : OutOfProcComponent
     {
+        private readonly VisualStudioWorkspace_InProc _inProc;
+
         internal VisualStudioWorkspace_OutOfProc(VisualStudioInstance visualStudioInstance)
             : base(visualStudioInstance)
         {
+            this._inProc = CreateInProcComponent<VisualStudioWorkspace_InProc>(visualStudioInstance);
         }
 
         public bool UseSuggestionMode
         {
             get
             {
-                return InProc.UseSuggestionMode;
+                return _inProc.UseSuggestionMode;
             }
 
             set
             {
-                InProc.UseSuggestionMode = value;
+                _inProc.UseSuggestionMode = value;
             }
         }
 
         public bool IsPrettyListingOn(string languageName)
         {
-            return InProc.IsPrettyListingOn(languageName);
+            return _inProc.IsPrettyListingOn(languageName);
         }
 
         public void SetPrettyListing(string languageName, bool value)
         {
-            InProc.SetPrettyListing(languageName, value);
+            _inProc.SetPrettyListing(languageName, value);
         }
 
         public void WaitForAsyncOperations(string featuresToWaitFor, bool waitForWorkspaceFirst = true)
         {
-            InProc.WaitForAsyncOperations(featuresToWaitFor, waitForWorkspaceFirst);
+            _inProc.WaitForAsyncOperations(featuresToWaitFor, waitForWorkspaceFirst);
         }
 
         public void WaitForAllAsyncOperations()
         {
-            InProc.WaitForAllAsyncOperations();
+            _inProc.WaitForAllAsyncOperations();
         }
 
         public void CleanUpWorkspace()
         {
-            InProc.CleanUpWorkspace();
+            _inProc.CleanUpWorkspace();
         }
 
         public void CleanUpWaitingService()
         {
-            InProc.CleanUpWaitingService();
+            _inProc.CleanUpWaitingService();
         }
     }
 }