Including IVTs again

src/EditorFeatures/Core.Wpf/Microsoft.CodeAnalysis.EditorFeatures.Wpf.csproj

@@ -47,6 +47,7 @@
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.CSharp" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.InteractiveEditorFeatures" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.Remote.ServiceHub" />
+    <InternalsVisibleTo Include="FSharp.Editor" Key="$(FSharpKey)" />
     <InternalsVisibleTo Include="Microsoft.CodeAnalysis.ExternalAccess.FSharp" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.IntegrationTest.Utilities" />
     <InternalsVisibleTo Include="Roslyn.Services.Test.Utilities" />

src/EditorFeatures/Core/Implementation/Debugging/IBreakpointResolutionService.cs

 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;

src/EditorFeatures/Core/Microsoft.CodeAnalysis.EditorFeatures.csproj

@@ -106,6 +106,7 @@
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Remote.CSharp.15.7" Key="$(RemoteLanguageServiceKey)" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Remote.CSharp.15.8" Key="$(RemoteLanguageServiceKey)" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Remote.CSharp.16.0" Key="$(RemoteLanguageServiceKey)" />
+    <InternalsVisibleTo Include="FSharp.Editor" Key="$(FSharpKey)" />
     <InternalsVisibleTo Include="DynamicProxyGenAssembly2" Key="$(MoqPublicKey)" />
   </ItemGroup>
   <ItemGroup>

src/EditorFeatures/Text/Microsoft.CodeAnalysis.EditorFeatures.Text.csproj

@@ -53,6 +53,8 @@
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Remote.CSharp.16.0" Key="$(RemoteLanguageServiceKey)" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Xaml" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.VisualBasic.Repl" />
+    <InternalsVisibleTo Include="FSharp.Editor" Key="$(FSharpKey)" />
+    <InternalsVisibleTo Include="FSharp.LanguageService" Key="$(FSharpKey)" />
     <!-- BEGIN MONODEVELOP
     These MonoDevelop dependencies don't ship with Visual Studio, so can't break our
     binary insertions and are exempted from the ExternalAccess adapter assembly policies.

src/Features/Core/Portable/Completion/CommonCompletionItem.cs

@@ -10,7 +10,7 @@ namespace Microsoft.CodeAnalysis.Completion
 {
     internal static class CommonCompletionItem
     {
-        [Obsolete("This is a compatibility shim for FSharp; please do not use it.", error: true)]
+        [Obsolete("This is a compatibility shim for FSharp; please do not use it.")]
         public static CompletionItem Create(
             string displayText,
             CompletionItemRules rules,

src/Features/Core/Portable/Microsoft.CodeAnalysis.Features.csproj

@@ -94,6 +94,7 @@
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Remote.CSharp.15.7" Key="$(RemoteLanguageServiceKey)" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Remote.CSharp.15.8" Key="$(RemoteLanguageServiceKey)" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Remote.CSharp.16.0" Key="$(RemoteLanguageServiceKey)" />
+    <InternalsVisibleTo Include="FSharp.Editor" Key="$(FSharpKey)" />
     <InternalsVisibleTo Include="DynamicProxyGenAssembly2" Key="$(MoqPublicKey)" />
     <InternalsVisibleTo Include="Microsoft.Test.Apex.VisualStudio" Key="$(VisualStudioKey)" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.Alm.Shared.CodeAnalysisClient" Key="$(VisualStudioKey)" />

src/Tools/ExternalAccess/FSharp/Glyph.cs

@@ -120,7 +120,7 @@ internal static class GlyphHelpers
     {
         public static Glyph Convert(Microsoft.CodeAnalysis.Glyph glyph)
         {
-            switch(glyph)
+            switch (glyph)
             {
                 case Microsoft.CodeAnalysis.Glyph.None:
                     {
@@ -430,5 +430,318 @@ public static Glyph Convert(Microsoft.CodeAnalysis.Glyph glyph)
         }
     }
 
-
+    internal static class GlyphHelpersObsolete
+    {
+        [Obsolete("Only used to allow IVTs to work temporarily, will be removed when IVTs are fully removed.")]
+        public static Microsoft.CodeAnalysis.Glyph Convert(Glyph glyph)
+        {
+            switch (glyph)
+            {
+                case Glyph.None:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.None;
+                    }
+                case Glyph.Assembly:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Assembly;
+                    }
+                case Glyph.BasicFile:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.BasicFile;
+                    }
+                case Glyph.BasicProject:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.BasicProject;
+                    }
+                case Glyph.ClassPublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ClassPublic;
+                    }
+                case Glyph.ClassProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ClassProtected;
+                    }
+                case Glyph.ClassPrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ClassPrivate;
+                    }
+                case Glyph.ClassInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ClassInternal;
+                    }
+                case Glyph.CSharpFile:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.CSharpFile;
+                    }
+                case Glyph.CSharpProject:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.CSharpProject;
+                    }
+                case Glyph.ConstantPublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ConstantPublic;
+                    }
+                case Glyph.ConstantProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ConstantProtected;
+                    }
+                case Glyph.ConstantPrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ConstantPrivate;
+                    }
+                case Glyph.ConstantInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ConstantInternal;
+                    }
+                case Glyph.DelegatePublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.DelegatePublic;
+                    }
+                case Glyph.DelegateProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.DelegateProtected;
+                    }
+                case Glyph.DelegatePrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.DelegatePrivate;
+                    }
+                case Glyph.DelegateInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.DelegateInternal;
+                    }
+                case Glyph.EnumPublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EnumPublic;
+                    }
+                case Glyph.EnumProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EnumProtected;
+                    }
+                case Glyph.EnumPrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EnumPrivate;
+                    }
+                case Glyph.EnumInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EnumInternal;
+                    }
+                case Glyph.EnumMemberPublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EnumMemberPublic;
+                    }
+                case Glyph.EnumMemberProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EnumMemberProtected;
+                    }
+                case Glyph.EnumMemberPrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EnumMemberPrivate;
+                    }
+                case Glyph.EnumMemberInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EnumMemberInternal;
+                    }
+                case Glyph.Error:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Error;
+                    }
+                case Glyph.StatusInformation:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.StatusInformation;
+                    }
+                case Glyph.EventPublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EventPublic;
+                    }
+                case Glyph.EventProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EventProtected;
+                    }
+                case Glyph.EventPrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EventPrivate;
+                    }
+                case Glyph.EventInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.EventInternal;
+                    }
+                case Glyph.ExtensionMethodPublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ExtensionMethodPublic;
+                    }
+                case Glyph.ExtensionMethodProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ExtensionMethodProtected;
+                    }
+                case Glyph.ExtensionMethodPrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ExtensionMethodPrivate;
+                    }
+                case Glyph.ExtensionMethodInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ExtensionMethodInternal;
+                    }
+                case Glyph.FieldPublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.FieldPublic;
+                    }
+                case Glyph.FieldProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.FieldProtected;
+                    }
+                case Glyph.FieldPrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.FieldPrivate;
+                    }
+                case Glyph.FieldInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.FieldInternal;
+                    }
+                case Glyph.InterfacePublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.InterfacePublic;
+                    }
+                case Glyph.InterfaceProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.InterfaceProtected;
+                    }
+                case Glyph.InterfacePrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.InterfacePrivate;
+                    }
+                case Glyph.InterfaceInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.InterfaceInternal;
+                    }
+                case Glyph.Intrinsic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Intrinsic;
+                    }
+                case Glyph.Keyword:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Keyword;
+                    }
+                case Glyph.Label:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Label;
+                    }
+                case Glyph.Local:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Local;
+                    }
+                case Glyph.Namespace:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Namespace;
+                    }
+                case Glyph.MethodPublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.MethodPublic;
+                    }
+                case Glyph.MethodProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.MethodProtected;
+                    }
+                case Glyph.MethodPrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.MethodPrivate;
+                    }
+                case Glyph.MethodInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.MethodInternal;
+                    }
+                case Glyph.ModulePublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ModulePublic;
+                    }
+                case Glyph.ModuleProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ModuleProtected;
+                    }
+                case Glyph.ModulePrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ModulePrivate;
+                    }
+                case Glyph.ModuleInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.ModuleInternal;
+                    }
+                case Glyph.OpenFolder:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.OpenFolder;
+                    }
+                case Glyph.Operator:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Operator;
+                    }
+                case Glyph.Parameter:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Parameter;
+                    }
+                case Glyph.PropertyPublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.PropertyPublic;
+                    }
+                case Glyph.PropertyProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.PropertyProtected;
+                    }
+                case Glyph.PropertyPrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.PropertyPrivate;
+                    }
+                case Glyph.PropertyInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.PropertyInternal;
+                    }
+                case Glyph.RangeVariable:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.RangeVariable;
+                    }
+                case Glyph.Reference:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Reference;
+                    }
+                case Glyph.StructurePublic:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.StructurePublic;
+                    }
+                case Glyph.StructureProtected:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.StructureProtected;
+                    }
+                case Glyph.StructurePrivate:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.StructurePrivate;
+                    }
+                case Glyph.StructureInternal:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.StructureInternal;
+                    }
+                case Glyph.TypeParameter:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.TypeParameter;
+                    }
+                case Glyph.Snippet:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.Snippet;
+                    }
+                case Glyph.CompletionWarning:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.CompletionWarning;
+                    }
+                case Glyph.AddReference:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.AddReference;
+                    }
+                case Glyph.NuGet:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.NuGet;
+                    }
+                default:
+                    {
+                        return Microsoft.CodeAnalysis.Glyph.None;
+                    }
+            }
+        }
+    }
 }

src/Tools/ExternalAccess/FSharp/Microsoft.CodeAnalysis.ExternalAccess.FSharp.csproj

@@ -15,6 +15,13 @@
     </PackageDescription>
   </PropertyGroup>
 
+  <ItemGroup>
+    <!--
+      ⚠ ONLY F# ASSEMBLIES MAY BE ADDED HERE ⚠ - Will be removed soon once all IVTs are removed.
+    -->
+    <InternalsVisibleTo Include="FSharp.Editor" Key="$(FSharpKey)" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\..\..\Compilers\Core\Portable\Microsoft.CodeAnalysis.csproj" />
     <ProjectReference Include="..\..\..\EditorFeatures\Core\Microsoft.CodeAnalysis.EditorFeatures.csproj" />

src/VisualStudio/Core/Impl/Microsoft.VisualStudio.LanguageServices.Implementation.csproj

@@ -36,6 +36,8 @@
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Remote.CSharp.15.7" Key="$(RemoteLanguageServiceKey)" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Remote.CSharp.15.8" Key="$(RemoteLanguageServiceKey)" />
     <InternalsVisibleTo Include="Microsoft.VisualStudio.LanguageServices.Remote.CSharp.16.0" Key="$(RemoteLanguageServiceKey)" />
+    <InternalsVisibleTo Include="FSharp.Editor" Key="$(FSharpKey)" />
+    <InternalsVisibleTo Include="FSharp.LanguageService" Key="$(FSharpKey)" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="Microsoft.CSharp" />