Merge pull request #39910 from...

Merge pull request #39910 from jasonmalinowski/decouple-command-filters-and-contained-documents-from-language-service

Decouple command filters and contained documents from language service

src/VisualStudio/CSharp/Impl/Interactive/CSharpVsInteractiveWindowCommandProvider.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.
 
+#nullable enable
+
 using System.ComponentModel.Composition;
 using Microsoft.CodeAnalysis.Editor;
-using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.ComponentModelHost;
+using Microsoft.VisualStudio.InteractiveWindow.Commands;
+using Microsoft.VisualStudio.InteractiveWindow.Shell;
 using Microsoft.VisualStudio.LanguageServices.Interactive;
 using Microsoft.VisualStudio.OLE.Interop;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.Utilities;
-using Microsoft.VisualStudio.InteractiveWindow;
-using Microsoft.VisualStudio.InteractiveWindow.Commands;
-using Microsoft.VisualStudio.InteractiveWindow.Shell;
 
 namespace Microsoft.VisualStudio.LanguageServices.CSharp.Interactive
 {
@@ -19,21 +20,18 @@ namespace Microsoft.VisualStudio.LanguageServices.CSharp.Interactive
     [ContentType(PredefinedInteractiveCommandsContentTypes.InteractiveCommandContentTypeName)]
     internal sealed class CSharpVsInteractiveWindowCommandProvider : IVsInteractiveWindowOleCommandTargetProvider
     {
-        private readonly IVsEditorAdaptersFactoryService _editorAdaptersFactory;
         private readonly System.IServiceProvider _serviceProvider;
 
         [ImportingConstructor]
         public CSharpVsInteractiveWindowCommandProvider(
-            IVsEditorAdaptersFactoryService editorAdaptersFactoryService,
             SVsServiceProvider serviceProvider)
         {
-            _editorAdaptersFactory = editorAdaptersFactoryService;
             _serviceProvider = serviceProvider;
         }
 
         public IOleCommandTarget GetCommandTarget(IWpfTextView textView, IOleCommandTarget nextTarget)
         {
-            var target = new ScriptingOleCommandTarget(textView, _editorAdaptersFactory, _serviceProvider);
+            var target = new ScriptingOleCommandTarget(textView, (IComponentModel)_serviceProvider.GetService(typeof(SComponentModel)));
             target.NextCommandTarget = nextTarget;
             return target;
         }

src/VisualStudio/Core/Def/Implementation/AbstractOleCommandTarget.Execute.cs

@@ -148,7 +148,8 @@ private void ExecuteBrowserForward(Action executeNextCommandTarget)
         private void ExecuteBrowserNavigationCommand(bool navigateBackward, Action executeNextCommandTarget)
         {
             // We just want to delegate to the shell's NavigateBackward/Forward commands
-            if (_serviceProvider.GetService(typeof(SUIHostCommandDispatcher)) is IOleCommandTarget target)
+            System.IServiceProvider serviceProvider = ComponentModel.GetService<SVsServiceProvider>();
+            if (serviceProvider.GetService(typeof(SUIHostCommandDispatcher)) is IOleCommandTarget target)
             {
                 var cmd = (uint)(navigateBackward ?
                      VSConstants.VSStd97CmdID.ShellNavBackward :

src/VisualStudio/Core/Def/Implementation/AbstractOleCommandTarget.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.
 
+#nullable enable
+
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
-using Microsoft.VisualStudio;
+using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Editor;
 using Microsoft.VisualStudio.OLE.Interop;
 using Microsoft.VisualStudio.Text;
@@ -15,10 +17,6 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
     internal abstract partial class AbstractOleCommandTarget : IOleCommandTarget
     {
-        private readonly IWpfTextView _wpfTextView;
-        private readonly IVsEditorAdaptersFactoryService _editorAdaptersFactory;
-        private readonly System.IServiceProvider _serviceProvider;
-
         /// <summary>
         /// This is set only during Exec. Currently, this is required to disambiguate the editor calls to
         /// <see cref="IVsTextViewFilter.GetPairExtents(int, int, TextSpan[])"/> between GotoBrace and GotoBraceExt commands.
@@ -27,40 +25,38 @@ internal abstract partial class AbstractOleCommandTarget : IOleCommandTarget
 
         public AbstractOleCommandTarget(
             IWpfTextView wpfTextView,
-            IVsEditorAdaptersFactoryService editorAdaptersFactory,
-            System.IServiceProvider serviceProvider)
+            IComponentModel componentModel)
         {
             Contract.ThrowIfNull(wpfTextView);
-            Contract.ThrowIfNull(editorAdaptersFactory);
-            Contract.ThrowIfNull(serviceProvider);
+            Contract.ThrowIfNull(componentModel);
 
-            _wpfTextView = wpfTextView;
-            _editorAdaptersFactory = editorAdaptersFactory;
-            _serviceProvider = serviceProvider;
+            WpfTextView = wpfTextView;
+            ComponentModel = componentModel;
         }
 
+        public IComponentModel ComponentModel { get; }
+
         public IVsEditorAdaptersFactoryService EditorAdaptersFactory
         {
-            get { return _editorAdaptersFactory; }
+            get { return ComponentModel.GetService<IVsEditorAdaptersFactoryService>(); }
         }
 
         /// <summary>
         /// The IWpfTextView that this command filter is attached to.
         /// </summary>
-        public IWpfTextView WpfTextView
-        {
-            get { return _wpfTextView; }
-        }
+        public IWpfTextView WpfTextView { get; }
 
         /// <summary>
         /// The next command target in the chain. This is set by the derived implementation of this
         /// class.
         /// </summary>
-        protected internal IOleCommandTarget NextCommandTarget { get; set; }
+        [DisallowNull]
+        protected internal IOleCommandTarget? NextCommandTarget { get; set; }
 
         internal AbstractOleCommandTarget AttachToVsTextView()
         {
-            var vsTextView = _editorAdaptersFactory.GetViewAdapter(_wpfTextView);
+            var vsTextView = EditorAdaptersFactory.GetViewAdapter(WpfTextView);
+
             // Add command filter to IVsTextView. If something goes wrong, throw.
             var returnValue = vsTextView.AddCommandFilter(this, out var nextCommandTarget);
             Marshal.ThrowExceptionForHR(returnValue);
@@ -73,12 +69,12 @@ internal AbstractOleCommandTarget AttachToVsTextView()
 
         protected virtual ITextBuffer GetSubjectBufferContainingCaret()
         {
-            return _wpfTextView.GetBufferContainingCaret();
+            return WpfTextView.GetBufferContainingCaret();
         }
 
         protected virtual ITextView ConvertTextView()
         {
-            return _wpfTextView;
+            return WpfTextView;
         }
     }
 }

src/VisualStudio/Core/Def/Implementation/AbstractVsTextViewFilter.cs

@@ -3,32 +3,169 @@
 using System;
 using System.Linq;
 using System.Threading;
-using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.Editor;
+using Microsoft.CodeAnalysis.Editor.Host;
+using Microsoft.CodeAnalysis.Editor.Implementation.Debugging;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
+using Microsoft.CodeAnalysis.ErrorReporting;
+using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
-using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Extensions;
+using Microsoft.VisualStudio.Shell;
+using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.TextManager.Interop;
 using Roslyn.Utilities;
 using TextSpan = Microsoft.VisualStudio.TextManager.Interop.TextSpan;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
 {
-    internal abstract class AbstractVsTextViewFilter : AbstractOleCommandTarget
+    internal abstract class AbstractVsTextViewFilter : AbstractOleCommandTarget, IVsTextViewFilter
     {
         public AbstractVsTextViewFilter(
             IWpfTextView wpfTextView,
-            IVsEditorAdaptersFactoryService editorAdaptersFactoryService,
-            IServiceProvider systemServiceProvider)
-            : base(wpfTextView, editorAdaptersFactoryService, systemServiceProvider)
+            IComponentModel componentModel)
+            : base(wpfTextView, componentModel)
         {
         }
 
+        int IVsTextViewFilter.GetDataTipText(TextSpan[] pSpan, out string pbstrText)
+        {
+            try
+            {
+                if (pSpan == null || pSpan.Length != 1)
+                {
+                    pbstrText = null;
+                    return VSConstants.E_INVALIDARG;
+                }
+
+                return GetDataTipTextImpl(pSpan, out pbstrText);
+            }
+            catch (Exception e) when (FatalError.ReportWithoutCrash(e) && false)
+            {
+                throw ExceptionUtilities.Unreachable;
+            }
+        }
+
+        protected virtual int GetDataTipTextImpl(TextSpan[] pSpan, out string pbstrText)
+        {
+            var subjectBuffer = WpfTextView.GetBufferContainingCaret();
+            if (subjectBuffer == null)
+            {
+                pbstrText = null;
+                return VSConstants.E_FAIL;
+            }
+
+            return GetDataTipTextImpl(subjectBuffer, pSpan, out pbstrText);
+        }
+
+        protected int GetDataTipTextImpl(ITextBuffer subjectBuffer, TextSpan[] pSpan, out string pbstrText)
+        {
+            pbstrText = null;
+
+            var vsBuffer = EditorAdaptersFactory.GetBufferAdapter(subjectBuffer);
+
+            // TODO: broken in REPL
+            if (vsBuffer == null)
+            {
+                return VSConstants.E_FAIL;
+            }
+
+            using (Logger.LogBlock(FunctionId.Debugging_VsLanguageDebugInfo_GetDataTipText, CancellationToken.None))
+            {
+                pbstrText = null;
+                if (pSpan == null || pSpan.Length != 1)
+                {
+                    return VSConstants.E_INVALIDARG;
+                }
+
+                var result = VSConstants.E_FAIL;
+                string pbstrTextInternal = null;
+
+                var waitIndicator = ComponentModel.GetService<IWaitIndicator>();
+
+                waitIndicator.Wait(
+                    title: ServicesVSResources.Debugger,
+                    message: ServicesVSResources.Getting_DataTip_text,
+                    allowCancel: true,
+                    action: waitContext =>
+                {
+                    IServiceProvider serviceProvider = ComponentModel.GetService<SVsServiceProvider>();
+                    var debugger = (IVsDebugger)serviceProvider.GetService(typeof(SVsShellDebugger));
+                    var debugMode = new DBGMODE[1];
+
+                    var cancellationToken = waitContext.CancellationToken;
+                    if (ErrorHandler.Succeeded(debugger.GetMode(debugMode)) && debugMode[0] != DBGMODE.DBGMODE_Design)
+                    {
+                        var textSpan = pSpan[0];
+
+                        var textSnapshot = subjectBuffer.CurrentSnapshot;
+                        var document = textSnapshot.GetOpenDocumentInCurrentContextWithChanges();
+
+                        if (document != null)
+                        {
+                            var languageDebugInfo = document.Project.LanguageServices.GetService<ILanguageDebugInfoService>();
+                            if (languageDebugInfo != null)
+                            {
+                                var spanOpt = textSnapshot.TryGetSpan(textSpan);
+                                if (spanOpt.HasValue)
+                                {
+                                    var dataTipInfo = languageDebugInfo.GetDataTipInfoAsync(document, spanOpt.Value.Start, cancellationToken).WaitAndGetResult(cancellationToken);
+                                    if (!dataTipInfo.IsDefault)
+                                    {
+                                        var resultSpan = dataTipInfo.Span.ToSnapshotSpan(textSnapshot);
+                                        var textOpt = dataTipInfo.Text;
+
+                                        pSpan[0] = resultSpan.ToVsTextSpan();
+                                        result = debugger.GetDataTipValue((IVsTextLines)vsBuffer, pSpan, textOpt, out pbstrTextInternal);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+
+                pbstrText = pbstrTextInternal;
+                return result;
+            }
+        }
+
+        int IVsTextViewFilter.GetPairExtents(int iLine, int iIndex, TextSpan[] pSpan)
+        {
+            try
+            {
+                var result = VSConstants.S_OK;
+                ComponentModel.GetService<IWaitIndicator>().Wait(
+                    "Intellisense",
+                    allowCancel: true,
+                    action: c => result = GetPairExtentsWorker(iLine, iIndex, pSpan, c.CancellationToken));
+
+                return result;
+            }
+            catch (Exception e) when (FatalError.ReportWithoutCrash(e) && false)
+            {
+                throw ExceptionUtilities.Unreachable;
+            }
+        }
+
+        private int GetPairExtentsWorker(int iLine, int iIndex, TextSpan[] pSpan, CancellationToken cancellationToken)
+        {
+            var braceMatcher = ComponentModel.GetService<IBraceMatchingService>();
+            return GetPairExtentsWorker(
+                WpfTextView,
+                braceMatcher,
+                iLine,
+                iIndex,
+                pSpan,
+                (VSConstants.VSStd2KCmdID)this.CurrentlyExecutingCommand == VSConstants.VSStd2KCmdID.GOTOBRACE_EXT,
+                cancellationToken);
+        }
+
         // Internal for testing purposes
-        internal static int GetPairExtentsWorker(ITextView textView, CodeAnalysis.Workspace workspace, IBraceMatchingService braceMatcher, int iLine, int iIndex, TextSpan[] pSpan, bool extendSelection, CancellationToken cancellationToken)
+        internal static int GetPairExtentsWorker(ITextView textView, IBraceMatchingService braceMatcher, int iLine, int iIndex, TextSpan[] pSpan, bool extendSelection, CancellationToken cancellationToken)
         {
             pSpan[0].iStartLine = pSpan[0].iEndLine = iLine;
             pSpan[0].iStartIndex = pSpan[0].iEndIndex = iIndex;
@@ -116,5 +253,8 @@ internal static int GetPairExtentsWorker(ITextView textView, CodeAnalysis.Worksp
 
             return VSConstants.S_OK;
         }
+
+        int IVsTextViewFilter.GetWordExtent(int iLine, int iIndex, uint dwFlags, TextSpan[] pSpan)
+            => VSConstants.E_NOTIMPL;
     }
 }

src/VisualStudio/Core/Def/Implementation/AbstractVsTextViewFilter`2.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;
-using System.Threading;
-using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.Editor;
-using Microsoft.CodeAnalysis.Editor.Host;
-using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
-using Microsoft.CodeAnalysis.ErrorReporting;
-using Microsoft.CodeAnalysis.Text;
-using Microsoft.VisualStudio.Editor;
-using Microsoft.VisualStudio.LanguageServices.Implementation.EditAndContinue;
-using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
-using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
-using Microsoft.VisualStudio.Text;
-using Microsoft.VisualStudio.Text.Editor;
-using Microsoft.VisualStudio.TextManager.Interop;
-using Roslyn.Utilities;
-using TextSpan = Microsoft.VisualStudio.TextManager.Interop.TextSpan;
-
-namespace Microsoft.VisualStudio.LanguageServices.Implementation
-{
-    internal abstract class AbstractVsTextViewFilter<TPackage, TLanguageService> : AbstractVsTextViewFilter, IVsTextViewFilter
-        where TPackage : AbstractPackage<TPackage, TLanguageService>
-        where TLanguageService : AbstractLanguageService<TPackage, TLanguageService>
-    {
-        protected AbstractLanguageService<TPackage, TLanguageService> LanguageService { get; }
-
-        protected AbstractVsTextViewFilter(
-            AbstractLanguageService<TPackage, TLanguageService> languageService,
-            IWpfTextView wpfTextView,
-            IVsEditorAdaptersFactoryService editorAdaptersFactoryService)
-            : base(wpfTextView, editorAdaptersFactoryService, languageService.SystemServiceProvider)
-        {
-            LanguageService = languageService;
-        }
-
-        int IVsTextViewFilter.GetDataTipText(TextSpan[] pSpan, out string pbstrText)
-        {
-            try
-            {
-                if (pSpan == null || pSpan.Length != 1)
-                {
-                    pbstrText = null;
-                    return VSConstants.E_INVALIDARG;
-                }
-
-                var debugInfo = LanguageService.LanguageDebugInfo;
-                if (debugInfo == null)
-                {
-                    pbstrText = null;
-                    return VSConstants.E_FAIL;
-                }
-
-                return GetDataTipTextImpl(pSpan, debugInfo, out pbstrText);
-            }
-            catch (Exception e) when (FatalError.ReportWithoutCrash(e) && false)
-            {
-                throw ExceptionUtilities.Unreachable;
-            }
-        }
-
-        protected virtual int GetDataTipTextImpl(TextSpan[] pSpan, AbstractLanguageService<TPackage, TLanguageService>.VsLanguageDebugInfo debugInfo, out string pbstrText)
-        {
-            var subjectBuffer = WpfTextView.GetBufferContainingCaret();
-            if (subjectBuffer == null)
-            {
-                pbstrText = null;
-                return VSConstants.E_FAIL;
-            }
-
-            return GetDataTipTextImpl(subjectBuffer, pSpan, debugInfo, out pbstrText);
-        }
-
-        protected int GetDataTipTextImpl(ITextBuffer subjectBuffer, TextSpan[] pSpan, AbstractLanguageService<TPackage, TLanguageService>.VsLanguageDebugInfo debugInfo, out string pbstrText)
-        {
-            pbstrText = null;
-
-            var vsBuffer = EditorAdaptersFactory.GetBufferAdapter(subjectBuffer);
-
-            // TODO: broken in REPL
-            if (vsBuffer == null)
-            {
-                return VSConstants.E_FAIL;
-            }
-
-            return debugInfo.GetDataTipText(vsBuffer, pSpan, out pbstrText);
-        }
-
-        int IVsTextViewFilter.GetPairExtents(int iLine, int iIndex, TextSpan[] pSpan)
-        {
-            try
-            {
-                var result = VSConstants.S_OK;
-                LanguageService.Package.ComponentModel.GetService<IWaitIndicator>().Wait(
-                    "Intellisense",
-                    allowCancel: true,
-                    action: c => result = GetPairExtentsWorker(iLine, iIndex, pSpan, c.CancellationToken));
-
-                return result;
-            }
-            catch (Exception e) when (FatalError.ReportWithoutCrash(e) && false)
-            {
-                throw ExceptionUtilities.Unreachable;
-            }
-        }
-
-        private int GetPairExtentsWorker(int iLine, int iIndex, TextSpan[] pSpan, CancellationToken cancellationToken)
-        {
-            var braceMatcher = LanguageService.Package.ComponentModel.GetService<IBraceMatchingService>();
-            return GetPairExtentsWorker(
-                WpfTextView,
-                LanguageService.Workspace,
-                braceMatcher,
-                iLine,
-                iIndex,
-                pSpan,
-                (VSConstants.VSStd2KCmdID)this.CurrentlyExecutingCommand == VSConstants.VSStd2KCmdID.GOTOBRACE_EXT,
-                cancellationToken);
-        }
-
-        int IVsTextViewFilter.GetWordExtent(int iLine, int iIndex, uint dwFlags, TextSpan[] pSpan)
-            => VSConstants.E_NOTIMPL;
-    }
-}

src/VisualStudio/Core/Def/Implementation/DebuggerIntelliSense/DebuggerIntellisenseFilter.cs

@@ -3,12 +3,9 @@
 using System;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
-using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Editor;
-using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
 using Microsoft.VisualStudio.OLE.Interop;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
@@ -18,9 +15,7 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.DebuggerIntelliSense
 {
-    internal class DebuggerIntelliSenseFilter<TPackage, TLanguageService> : AbstractVsTextViewFilter<TPackage, TLanguageService>, IDisposable, IFeatureController
-        where TPackage : AbstractPackage<TPackage, TLanguageService>
-        where TLanguageService : AbstractLanguageService<TPackage, TLanguageService>
+    internal class DebuggerIntelliSenseFilter : AbstractVsTextViewFilter, IDisposable, IFeatureController
     {
         private readonly IFeatureServiceFactory _featureServiceFactory;
         private AbstractDebuggerIntelliSenseContext _context;
@@ -28,11 +23,10 @@ internal class DebuggerIntelliSenseFilter<TPackage, TLanguageService> : Abstract
         private IFeatureDisableToken _completionDisabledToken;
 
         public DebuggerIntelliSenseFilter(
-            AbstractLanguageService<TPackage, TLanguageService> languageService,
             IWpfTextView wpfTextView,
-            IVsEditorAdaptersFactoryService adapterFactory,
+            IComponentModel componentModel,
             IFeatureServiceFactory featureServiceFactory)
-            : base(languageService, wpfTextView, adapterFactory)
+            : base(wpfTextView, componentModel)
         {
             _featureServiceFactory = featureServiceFactory;
         }
@@ -78,8 +72,7 @@ private void SetNextFilterWorker()
             {
                 // Chain in editor command handler service. It will execute all our command handlers migrated to the modern editor commanding
                 // on the same text view and buffer as this.CurrentHandlers.
-                var componentModel = (IComponentModel)LanguageService.SystemServiceProvider.GetService(typeof(SComponentModel));
-                var vsCommandHandlerServiceAdapterFactory = componentModel.GetService<IVsCommandHandlerServiceAdapterFactory>();
+                var vsCommandHandlerServiceAdapterFactory = ComponentModel.GetService<IVsCommandHandlerServiceAdapterFactory>();
                 var vsCommandHandlerServiceAdapter = vsCommandHandlerServiceAdapterFactory.Create(ConvertTextView(),
                     GetSubjectBufferContainingCaret(), // our override doesn't actually check the caret and always returns _context.Buffer
                     nextCommandFilter);

src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.IVsImmediateStatementCompletion2.cs

@@ -4,9 +4,7 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.ErrorReporting;
-using Microsoft.VisualStudio.Editor;
 using Microsoft.VisualStudio.LanguageServices.Implementation.DebuggerIntelliSense;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
@@ -17,8 +15,8 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService
 {
     internal abstract partial class AbstractLanguageService<TPackage, TLanguageService> : IVsImmediateStatementCompletion2
     {
-        protected Dictionary<IVsTextView, DebuggerIntelliSenseFilter<TPackage, TLanguageService>> filters =
-            new Dictionary<IVsTextView, DebuggerIntelliSenseFilter<TPackage, TLanguageService>>();
+        protected Dictionary<IVsTextView, DebuggerIntelliSenseFilter> filters =
+            new Dictionary<IVsTextView, DebuggerIntelliSenseFilter>();
 
         int IVsImmediateStatementCompletion2.EnableStatementCompletion(int enable, int startIndex, int endIndex, IVsTextView textView)
         {
@@ -47,12 +45,12 @@ int IVsImmediateStatementCompletion2.InstallStatementCompletion(int install, IVs
             // of textview->filters.
             if (install != 0)
             {
-                DebuggerIntelliSenseFilter<TPackage, TLanguageService> filter;
+                DebuggerIntelliSenseFilter filter;
                 if (!this.filters.ContainsKey(textView))
                 {
-                    filter = new DebuggerIntelliSenseFilter<TPackage, TLanguageService>(this,
+                    filter = new DebuggerIntelliSenseFilter(
                         this.EditorAdaptersFactoryService.GetWpfTextView(textView),
-                        this.Package.ComponentModel.GetService<IVsEditorAdaptersFactoryService>(),
+                        this.Package.ComponentModel,
                         this.Package.ComponentModel.GetService<IFeatureServiceFactory>());
                     this.filters[textView] = filter;
                     Marshal.ThrowExceptionForHR(textView.AddCommandFilter(filter, out var nextFilter));

src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.VsLanguageDebugInfo.cs

@@ -13,12 +13,10 @@
 using Microsoft.VisualStudio.LanguageServices.Implementation.Debugging;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Extensions;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Utilities;
-using Microsoft.VisualStudio.Shell.Interop;
 using Roslyn.Utilities;
 using IVsDebugName = Microsoft.VisualStudio.TextManager.Interop.IVsDebugName;
 using IVsEnumBSTR = Microsoft.VisualStudio.TextManager.Interop.IVsEnumBSTR;
 using IVsTextBuffer = Microsoft.VisualStudio.TextManager.Interop.IVsTextBuffer;
-using IVsTextLines = Microsoft.VisualStudio.TextManager.Interop.IVsTextLines;
 using RESOLVENAMEFLAGS = Microsoft.VisualStudio.TextManager.Interop.RESOLVENAMEFLAGS;
 using VsTextSpan = Microsoft.VisualStudio.TextManager.Interop.TextSpan;
 
@@ -372,63 +370,6 @@ public int ValidateBreakpointLocation(IVsTextBuffer pBuffer, int iLine, int iCol
 
                 return VSConstants.E_NOTIMPL;
             }
-
-            public int GetDataTipText(IVsTextBuffer pBuffer, VsTextSpan[] pSpan, out string pbstrText)
-            {
-                using (Logger.LogBlock(FunctionId.Debugging_VsLanguageDebugInfo_GetDataTipText, CancellationToken.None))
-                {
-                    pbstrText = null;
-                    if (pSpan == null || pSpan.Length != 1)
-                    {
-                        return VSConstants.E_INVALIDARG;
-                    }
-
-                    var result = VSConstants.E_FAIL;
-                    string pbstrTextInternal = null;
-
-                    _waitIndicator.Wait(
-                        title: ServicesVSResources.Debugger,
-                        message: ServicesVSResources.Getting_DataTip_text,
-                        allowCancel: true,
-                        action: waitContext =>
-                    {
-                        var debugger = _languageService.Debugger;
-                        var debugMode = new DBGMODE[1];
-
-                        var cancellationToken = waitContext.CancellationToken;
-                        if (ErrorHandler.Succeeded(debugger.GetMode(debugMode)) && debugMode[0] != DBGMODE.DBGMODE_Design)
-                        {
-                            var editorAdapters = _languageService.EditorAdaptersFactoryService;
-
-                            var textSpan = pSpan[0];
-                            var subjectBuffer = editorAdapters.GetDataBuffer(pBuffer);
-
-                            var textSnapshot = subjectBuffer.CurrentSnapshot;
-                            var document = textSnapshot.GetOpenDocumentInCurrentContextWithChanges();
-
-                            if (document != null)
-                            {
-                                var spanOpt = textSnapshot.TryGetSpan(textSpan);
-                                if (spanOpt.HasValue)
-                                {
-                                    var dataTipInfo = _languageDebugInfo.GetDataTipInfoAsync(document, spanOpt.Value.Start, cancellationToken).WaitAndGetResult(cancellationToken);
-                                    if (!dataTipInfo.IsDefault)
-                                    {
-                                        var resultSpan = dataTipInfo.Span.ToSnapshotSpan(textSnapshot);
-                                        var textOpt = dataTipInfo.Text;
-
-                                        pSpan[0] = resultSpan.ToVsTextSpan();
-                                        result = debugger.GetDataTipValue((IVsTextLines)pBuffer, pSpan, textOpt, out pbstrTextInternal);
-                                    }
-                                }
-                            }
-                        }
-                    });
-
-                    pbstrText = pbstrTextInternal;
-                    return result;
-                }
-            }
         }
     }
 }

src/VisualStudio/Core/Def/Implementation/LanguageService/AbstractLanguageService`2.cs

@@ -228,14 +228,14 @@ protected virtual void SetupNewTextView(IVsTextView textView)
             var wpfTextView = EditorAdaptersFactoryService.GetWpfTextView(textView);
             Contract.ThrowIfNull(wpfTextView, "Could not get IWpfTextView for IVsTextView");
 
-            Debug.Assert(!wpfTextView.Properties.ContainsProperty(typeof(AbstractVsTextViewFilter<TPackage, TLanguageService>)));
+            Debug.Assert(!wpfTextView.Properties.ContainsProperty(typeof(AbstractVsTextViewFilter)));
 
             var workspace = Package.ComponentModel.GetService<VisualStudioWorkspace>();
 
             // The lifetime of CommandFilter is married to the view
             wpfTextView.GetOrCreateAutoClosingProperty(v =>
-                new StandaloneCommandFilter<TPackage, TLanguageService>(
-                    (TLanguageService)this, v, EditorAdaptersFactoryService).AttachToVsTextView());
+                new StandaloneCommandFilter(
+                    v, Package.ComponentModel).AttachToVsTextView());
 
             var openDocument = wpfTextView.TextBuffer.AsTextContainer().GetRelatedDocuments().FirstOrDefault();
             var isOpenMetadataAsSource = openDocument != null && openDocument.Project.Solution.Workspace.Kind == WorkspaceKind.MetadataAsSource;
@@ -387,9 +387,9 @@ private void UninitializeDebugMode()
             IVsTextBufferCoordinator bufferCoordinator, VisualStudioProject project,
             IVsHierarchy hierarchy, uint itemid)
         {
-            return new ContainedLanguage<TPackage, TLanguageService>(
+            return new ContainedLanguage(
                 bufferCoordinator, this.Package.ComponentModel, project, hierarchy, itemid, projectTrackerOpt: null, project.Id,
-                (TLanguageService)this);
+                this.LanguageServiceId);
         }
     }
 }

src/VisualStudio/Core/Def/Implementation/StandaloneCommandFilter.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;
-using Microsoft.CodeAnalysis.Editor;
-using Microsoft.VisualStudio.Editor;
-using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
+#nullable enable
+
+using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Text.Editor;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation
@@ -11,21 +10,16 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation
     /// <summary>
     /// A CommandFilter used for "normal" files, as opposed to Venus files which are special.
     /// </summary>
-    internal sealed class StandaloneCommandFilter<TPackage, TLanguageService> : AbstractVsTextViewFilter<TPackage, TLanguageService>
-        where TPackage : AbstractPackage<TPackage, TLanguageService>
-        where TLanguageService : AbstractLanguageService<TPackage, TLanguageService>
+    internal sealed class StandaloneCommandFilter : AbstractVsTextViewFilter
     {
         /// <summary>
         /// Creates a new command handler that is attached to an IVsTextView.
         /// </summary>
         /// <param name="wpfTextView">The IWpfTextView of the view.</param>
-        /// <param name="editorAdaptersFactoryService">The editor adapter</param>
-        /// <param name="languageService">The language service</param>
         internal StandaloneCommandFilter(
-            TLanguageService languageService,
             IWpfTextView wpfTextView,
-            IVsEditorAdaptersFactoryService editorAdaptersFactoryService)
-            : base(languageService, wpfTextView, editorAdaptersFactoryService)
+            IComponentModel componentModel)
+            : base(wpfTextView, componentModel)
         {
         }
     }

src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguage.IVsContainedCode.cs

@@ -14,7 +14,7 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Venus
 {
-    internal partial class ContainedLanguage<TPackage, TLanguageService> : IVsContainedCode
+    internal partial class ContainedLanguage : IVsContainedCode
     {
         public int HostSpansUpdated()
         {

src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguage.IVsContainedLanguage.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;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.VisualStudio.OLE.Interop;
 using Microsoft.VisualStudio.Text.Editor;
 using Microsoft.VisualStudio.TextManager.Interop;
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Venus
 {
-    internal partial class ContainedLanguage<TPackage, TLanguageService> : IVsContainedLanguage
+    internal partial class ContainedLanguage : IVsContainedLanguage
     {
         public int GetColorizer(out IVsColorizer colorizer)
         {
@@ -19,7 +18,7 @@ public int GetColorizer(out IVsColorizer colorizer)
 
         public int GetLanguageServiceID(out Guid guidLangService)
         {
-            guidLangService = _languageService.LanguageServiceId;
+            guidLangService = _languageServiceGuid;
             return VSConstants.S_OK;
         }
 
@@ -36,7 +35,7 @@ public int GetLanguageServiceID(out Guid guidLangService)
                 return VSConstants.E_FAIL;
             }
 
-            textViewFilter = new VenusCommandFilter<TPackage, TLanguageService>(_languageService, wpfTextView, SubjectBuffer, nextCmdTarget, _editorAdaptersFactoryService);
+            textViewFilter = new VenusCommandFilter(wpfTextView, SubjectBuffer, nextCmdTarget, ComponentModel);
 
             return VSConstants.S_OK;
         }

src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguage.IVsContainedLanguageCodeSupport.cs

@@ -14,7 +14,7 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Venus
 {
-    internal partial class ContainedLanguage<TPackage, TLanguageService> : IVsContainedLanguageCodeSupport
+    internal partial class ContainedLanguage : IVsContainedLanguageCodeSupport
     {
         public int CreateUniqueEventName(string pszClassName, string pszObjectName, string pszNameOfEvent, out string pbstrEventHandlerName)
         {

src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguage.cs

@@ -11,7 +11,6 @@
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Editor;
-using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
 using Microsoft.VisualStudio.Shell.Interop;
 using Microsoft.VisualStudio.Text;
@@ -23,13 +22,11 @@ namespace Microsoft.VisualStudio.LanguageServices.Implementation.Venus
 {
     using Workspace = Microsoft.CodeAnalysis.Workspace;
 
-    internal partial class ContainedLanguage<TPackage, TLanguageService>
-        where TPackage : AbstractPackage<TPackage, TLanguageService>
-        where TLanguageService : AbstractLanguageService<TPackage, TLanguageService>
+    internal partial class ContainedLanguage
     {
         private readonly IVsEditorAdaptersFactoryService _editorAdaptersFactoryService;
         private readonly IDiagnosticAnalyzerService _diagnosticAnalyzerService;
-        private readonly TLanguageService _languageService;
+        private readonly Guid _languageServiceGuid;
 
         protected readonly Workspace Workspace;
         protected readonly IComponentModel ComponentModel;
@@ -69,53 +66,6 @@ internal partial class ContainedLanguage<TPackage, TLanguageService>
         // flickering.
         private ITagAggregator<ITag> _bufferTagAggregator;
 
-        [Obsolete("This is a compatibility shim for TypeScript and Live Share; please do not use it.")]
-        public ContainedLanguage(
-            IVsTextBufferCoordinator bufferCoordinator,
-            IComponentModel componentModel,
-            AbstractProject project,
-            IVsHierarchy hierarchy,
-            uint itemid,
-            TLanguageService languageService,
-            SourceCodeKind sourceCodeKind,
-            IFormattingRule vbHelperFormattingRule,
-            Workspace workspace)
-            : this(bufferCoordinator,
-                   componentModel,
-                   project.VisualStudioProject,
-                   hierarchy,
-                   itemid,
-                   project.ProjectTracker,
-                   project.Id,
-                   languageService,
-                   vbHelperFormattingRule: null)
-        {
-            Contract.ThrowIfTrue(vbHelperFormattingRule != null);
-        }
-
-        [Obsolete("This is a compatibility shim for TypeScript; please do not use it.")]
-        public ContainedLanguage(
-            IVsTextBufferCoordinator bufferCoordinator,
-            IComponentModel componentModel,
-            AbstractProject project,
-            IVsHierarchy hierarchy,
-            uint itemid,
-            TLanguageService languageService,
-            SourceCodeKind sourceCodeKind,
-            IFormattingRule vbHelperFormattingRule)
-            : this(bufferCoordinator,
-                   componentModel,
-                   project.VisualStudioProject,
-                   hierarchy,
-                   itemid,
-                   projectTrackerOpt: null,
-                   project.VisualStudioProject.Id,
-                   languageService,
-                   vbHelperFormattingRule: null)
-        {
-            Contract.ThrowIfTrue(vbHelperFormattingRule != null);
-        }
-
         internal ContainedLanguage(
             IVsTextBufferCoordinator bufferCoordinator,
             IComponentModel componentModel,
@@ -124,13 +74,13 @@ internal partial class ContainedLanguage<TPackage, TLanguageService>
             uint itemid,
             VisualStudioProjectTracker projectTrackerOpt,
             ProjectId projectId,
-            TLanguageService languageService,
+            Guid languageServiceGuid,
             AbstractFormattingRule vbHelperFormattingRule = null)
         {
             this.BufferCoordinator = bufferCoordinator;
             this.ComponentModel = componentModel;
             this.Project = project;
-            _languageService = languageService;
+            _languageServiceGuid = languageServiceGuid;
 
             this.Workspace = projectTrackerOpt?.Workspace ?? componentModel.GetService<VisualStudioWorkspace>();
 

src/VisualStudio/Core/Def/Implementation/Venus/ContainedLanguage`2.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;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Formatting.Rules;
+using Microsoft.VisualStudio.ComponentModelHost;
+using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
+using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
+using Microsoft.VisualStudio.Shell.Interop;
+using Microsoft.VisualStudio.TextManager.Interop;
+using Roslyn.Utilities;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.Venus
+{
+    [Obsolete("This is a compatibility shim for TypeScript and Live Share; please do not use it.")]
+    internal partial class ContainedLanguage<TPackage, TLanguageService> : ContainedLanguage
+        where TPackage : AbstractPackage<TPackage, TLanguageService>
+        where TLanguageService : AbstractLanguageService<TPackage, TLanguageService>
+    {
+        [Obsolete("This is a compatibility shim for TypeScript and Live Share; please do not use it.")]
+        public ContainedLanguage(
+            IVsTextBufferCoordinator bufferCoordinator,
+            IComponentModel componentModel,
+            AbstractProject project,
+            IVsHierarchy hierarchy,
+            uint itemid,
+            TLanguageService languageService,
+            SourceCodeKind sourceCodeKind,
+            IFormattingRule vbHelperFormattingRule,
+            Workspace workspace)
+            : base(bufferCoordinator,
+                   componentModel,
+                   project.VisualStudioProject,
+                   hierarchy,
+                   itemid,
+                   project.ProjectTracker,
+                   project.Id,
+                   languageService.LanguageServiceId,
+                   vbHelperFormattingRule: null)
+        {
+            Contract.ThrowIfTrue(vbHelperFormattingRule != null);
+        }
+
+        [Obsolete("This is a compatibility shim for TypeScript; please do not use it.")]
+        public ContainedLanguage(
+            IVsTextBufferCoordinator bufferCoordinator,
+            IComponentModel componentModel,
+            AbstractProject project,
+            IVsHierarchy hierarchy,
+            uint itemid,
+            TLanguageService languageService,
+            SourceCodeKind sourceCodeKind,
+            IFormattingRule vbHelperFormattingRule)
+            : base(bufferCoordinator,
+                   componentModel,
+                   project.VisualStudioProject,
+                   hierarchy,
+                   itemid,
+                   projectTrackerOpt: null,
+                   project.VisualStudioProject.Id,
+                   languageService.LanguageServiceId,
+                   vbHelperFormattingRule: null)
+        {
+            Contract.ThrowIfTrue(vbHelperFormattingRule != null);
+        }
+    }
+}

src/VisualStudio/Core/Def/Implementation/Venus/VenusCommandFilter.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;
 using System.Diagnostics;
 using System.Linq;
-using Microsoft.CodeAnalysis.Editor;
 using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Editor;
 using Microsoft.VisualStudio.LanguageServices.Implementation.Extensions;
-using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
 using Microsoft.VisualStudio.OLE.Interop;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
@@ -16,19 +13,16 @@
 
 namespace Microsoft.VisualStudio.LanguageServices.Implementation.Venus
 {
-    internal class VenusCommandFilter<TPackage, TLanguageService> : AbstractVsTextViewFilter<TPackage, TLanguageService>
-        where TPackage : AbstractPackage<TPackage, TLanguageService>
-        where TLanguageService : AbstractLanguageService<TPackage, TLanguageService>
+    internal class VenusCommandFilter : AbstractVsTextViewFilter
     {
         private readonly ITextBuffer _subjectBuffer;
 
         public VenusCommandFilter(
-            TLanguageService languageService,
             IWpfTextView wpfTextView,
             ITextBuffer subjectBuffer,
             IOleCommandTarget nextCommandTarget,
-            IVsEditorAdaptersFactoryService editorAdaptersFactoryService)
-            : base(languageService, wpfTextView, editorAdaptersFactoryService)
+            IComponentModel componentModel)
+            : base(wpfTextView, componentModel)
         {
             Contract.ThrowIfNull(wpfTextView);
             Contract.ThrowIfNull(subjectBuffer);
@@ -37,30 +31,17 @@ internal class VenusCommandFilter<TPackage, TLanguageService> : AbstractVsTextVi
             _subjectBuffer = subjectBuffer;
 
             // Chain in editor command handler service. It will execute all our command handlers migrated to the modern editor commanding.
-            var componentModel = (IComponentModel)languageService.SystemServiceProvider.GetService(typeof(SComponentModel));
             var vsCommandHandlerServiceAdapterFactory = componentModel.GetService<IVsCommandHandlerServiceAdapterFactory>();
             var vsCommandHandlerServiceAdapter = vsCommandHandlerServiceAdapterFactory.Create(wpfTextView, _subjectBuffer, nextCommandTarget);
             NextCommandTarget = vsCommandHandlerServiceAdapter;
         }
 
-        [Obsolete("This is a compatibility shim for TypeScript; please do not use it.")]
-        public VenusCommandFilter(
-            TLanguageService languageService,
-            IWpfTextView wpfTextView,
-            ICommandHandlerServiceFactory commandHandlerServiceFactory,
-            ITextBuffer subjectBuffer,
-            IOleCommandTarget nextCommandTarget,
-            IVsEditorAdaptersFactoryService editorAdaptersFactoryService)
-            : this(languageService, wpfTextView, subjectBuffer, nextCommandTarget, editorAdaptersFactoryService)
-        {
-        }
-
         protected override ITextBuffer GetSubjectBufferContainingCaret()
         {
             return _subjectBuffer;
         }
 
-        protected override int GetDataTipTextImpl(TextSpan[] pSpan, AbstractLanguageService<TPackage, TLanguageService>.VsLanguageDebugInfo debugInfo, out string pbstrText)
+        protected override int GetDataTipTextImpl(TextSpan[] pSpan, out string pbstrText)
         {
             var textViewModel = WpfTextView.TextViewModel;
             if (textViewModel == null)
@@ -89,7 +70,7 @@ protected override int GetDataTipTextImpl(TextSpan[] pSpan, AbstractLanguageServ
                 // Next, we'll check to see if there is actually a DataTip for this candidate.
                 // If there is, we'll map this span back to the DataBuffer and return it.
                 pSpan[0] = candidateSpan.ToVsTextSpan();
-                var hr = base.GetDataTipTextImpl(_subjectBuffer, pSpan, debugInfo, out pbstrText);
+                var hr = base.GetDataTipTextImpl(_subjectBuffer, pSpan, out pbstrText);
                 if (ErrorHandler.Succeeded(hr))
                 {
                     var subjectSpan = _subjectBuffer.CurrentSnapshot.GetSpan(pSpan[0]);

src/VisualStudio/Core/Def/Implementation/Venus/VenusCommandFilter`2.cs

+using System;
+using Microsoft.CodeAnalysis.Editor;
+using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService;
+using Microsoft.VisualStudio.OLE.Interop;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+
+namespace Microsoft.VisualStudio.LanguageServices.Implementation.Venus
+{
+    [Obsolete("This is a compatibility shim for LiveShare and TypeScript; please do not use it.")]
+    internal class VenusCommandFilter<TPackage, TLanguageService> : VenusCommandFilter
+        where TPackage : AbstractPackage<TPackage, TLanguageService>
+        where TLanguageService : AbstractLanguageService<TPackage, TLanguageService>
+    {
+        [Obsolete("This is a compatibility shim for TypeScript; please do not use it.")]
+        public VenusCommandFilter(
+            TLanguageService languageService,
+            IWpfTextView wpfTextView,
+            ICommandHandlerServiceFactory commandHandlerServiceFactory,
+            ITextBuffer subjectBuffer,
+            IOleCommandTarget nextCommandTarget,
+            IVsEditorAdaptersFactoryService editorAdaptersFactoryService)
+            : base(wpfTextView, subjectBuffer, nextCommandTarget, languageService.Package.ComponentModel)
+        {
+        }
+    }
+}

src/VisualStudio/Core/Def/Interactive/ScriptingOleCommandTarget.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;
+#nullable enable
+
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
-using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.ComponentModelHost;
+using Microsoft.VisualStudio.InteractiveWindow.Commands;
 using Microsoft.VisualStudio.LanguageServices.Implementation;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
-using Microsoft.VisualStudio.InteractiveWindow;
-using Microsoft.VisualStudio.InteractiveWindow.Commands;
 
 namespace Microsoft.VisualStudio.LanguageServices.Interactive
 {
@@ -20,9 +20,8 @@ internal sealed class ScriptingOleCommandTarget : AbstractOleCommandTarget
     {
         internal ScriptingOleCommandTarget(
             IWpfTextView wpfTextView,
-            IVsEditorAdaptersFactoryService editorAdaptersFactory,
-            IServiceProvider serviceProvider)
-            : base(wpfTextView, editorAdaptersFactory, serviceProvider)
+            IComponentModel componentModel)
+            : base(wpfTextView, componentModel)
         {
         }
 

src/VisualStudio/Core/Test/AbstractTextViewFilterTests.vb

@@ -249,7 +249,6 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests
             Dim spans() = {New VsTextSpan()}
             Assert.Equal(0, AbstractVsTextViewFilter.GetPairExtentsWorker(
                          document.GetTextView(),
-                         workspace,
                          braceMatcher,
                          initialLineNumber,
                          initialIndex,
@@ -271,7 +270,6 @@ Namespace Microsoft.VisualStudio.LanguageServices.UnitTests
             Dim spans() = {New VsTextSpan()}
             Assert.Equal(0, AbstractVsTextViewFilter.GetPairExtentsWorker(
                          document.GetTextView(),
-                         workspace,
                          braceMatcher,
                          initialLineNumber,
                          initialIndex,

src/VisualStudio/VisualBasic/Impl/LanguageService/VisualBasicLanguageService.vb

@@ -6,7 +6,6 @@ Imports Microsoft.CodeAnalysis.Editor
 Imports Microsoft.VisualStudio.LanguageServices.Implementation.DebuggerIntelliSense
 Imports Microsoft.VisualStudio.LanguageServices.Implementation.LanguageService
 Imports Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem
-Imports Microsoft.VisualStudio.LanguageServices.VisualBasic.ProjectSystemShim
 Imports Microsoft.VisualStudio.LanguageServices.VisualBasic.Venus
 Imports Microsoft.VisualStudio.Shell.Interop
 Imports Microsoft.VisualStudio.Text
@@ -83,7 +82,8 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic
                 project,
                 hierarchy,
                 itemid,
-                Me, SourceCodeKind.Regular)
+                Me.LanguageServiceId,
+                SourceCodeKind.Regular)
         End Function
     End Class
 End Namespace

src/VisualStudio/VisualBasic/Impl/Venus/VisualBasicContainedLanguage.vb

@@ -18,7 +18,7 @@ Imports VsTextSpan = Microsoft.VisualStudio.TextManager.Interop.TextSpan
 Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Venus
 
     Friend Class VisualBasicContainedLanguage
-        Inherits ContainedLanguage(Of VisualBasicPackage, VisualBasicLanguageService)
+        Inherits ContainedLanguage
         Implements IVsContainedLanguageStaticEventBinding
 
         Public Sub New(bufferCoordinator As IVsTextBufferCoordinator,
@@ -26,9 +26,9 @@ Namespace Microsoft.VisualStudio.LanguageServices.VisualBasic.Venus
                 project As VisualStudioProject,
                 hierarchy As IVsHierarchy,
                 itemid As UInteger,
-                languageService As VisualBasicLanguageService,
+                languageServiceGuid As Guid,
                 sourceCodeKind As SourceCodeKind)
-            MyBase.New(bufferCoordinator, componentModel, project, hierarchy, itemid, projectTrackerOpt:=Nothing, project.Id, languageService, VisualBasicHelperFormattingRule.Instance)
+            MyBase.New(bufferCoordinator, componentModel, project, hierarchy, itemid, projectTrackerOpt:=Nothing, project.Id, languageServiceGuid, VisualBasicHelperFormattingRule.Instance)
         End Sub
 
         Public Function AddStaticEventBinding(pszClassName As String,

src/VisualStudio/Xaml/Impl/Implementation/XamlOleCommandTarget.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;
+#nullable enable
+
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
-using Microsoft.CodeAnalysis.Editor.Xaml;
-using Microsoft.VisualStudio.Editor;
+using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.LanguageServices.Implementation;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
@@ -18,9 +18,8 @@ internal sealed class XamlOleCommandTarget : AbstractOleCommandTarget
     {
         internal XamlOleCommandTarget(
             IWpfTextView wpfTextView,
-            IVsEditorAdaptersFactoryService editorAdaptersFactory,
-            IServiceProvider serviceProvider)
-            : base(wpfTextView, editorAdaptersFactory, serviceProvider)
+            IComponentModel componentModel)
+            : base(wpfTextView, componentModel)
         {
         }
 

src/VisualStudio/Xaml/Impl/Implementation/XamlTextViewCreationListener.cs

@@ -10,6 +10,7 @@
 using Microsoft.CodeAnalysis.Editor;
 using Microsoft.CodeAnalysis.Editor.Xaml;
 using Microsoft.CodeAnalysis.Xaml.Diagnostics.Analyzers;
+using Microsoft.VisualStudio.ComponentModelHost;
 using Microsoft.VisualStudio.Editor;
 using Microsoft.VisualStudio.LanguageServices.Implementation.ProjectSystem;
 using Microsoft.VisualStudio.Shell;
@@ -113,7 +114,7 @@ public void VsTextViewCreated(IVsTextView vsTextView)
             AttachRunningDocTableEvents();
 
             var wpfTextView = _editorAdaptersFactory.GetWpfTextView(vsTextView);
-            var target = new XamlOleCommandTarget(wpfTextView, _editorAdaptersFactory, _serviceProvider);
+            var target = new XamlOleCommandTarget(wpfTextView, (IComponentModel)_serviceProvider.GetService(typeof(SComponentModel)));
             target.AttachToVsTextView();
         }