抽象CompletionSourceBase、CompletionSourceProviderBase

Author: stratosblue

src/ChinesePinyinIntelliSenseExtender.csproj

@@ -70,6 +70,8 @@
     </Compile>
     <Compile Include="Options\OptionPages.cs" />
     <Compile Include="Options\Model\GeneralOptions.cs" />
+    <Compile Include="Completion\CompletionSourceBase.cs" />
+    <Compile Include="Completion\CompletionSourceProviderBase.cs" />
     <Compile Include="Ref\InputMethodDictionary\InputMethodDictionaryUtilities.cs" />
     <Compile Include="Ref\InputMethodDictionary\InputMethodReverseDictionary.cs" />
     <Compile Include="Ref\InputMethodDictionary\ITextAdjuster.cs" />
@@ -98,8 +100,8 @@
     <Compile Include="Usings.cs" />
     <Compile Include="Util\StringPreMatchUtil.cs" />
     <Compile Include="Util\InputMethodDictionaryLoader.cs" />
-    <Compile Include="PinyinAsyncCompletionSource.cs" />
-    <Compile Include="PinyinAsyncCompletionSourceProvider.cs" />
+    <Compile Include="Completion\Async\PinyinAsyncCompletionSource.cs" />
+    <Compile Include="Completion\Async\PinyinAsyncCompletionSourceProvider.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Util\ChineseCheckUtil.cs" />
     <Compile Include="ObjectBoolean.cs" />

src/PinyinAsyncCompletionSource.cs …ion/Async/PinyinAsyncCompletionSource.cssrc/PinyinAsyncCompletionSource.cs renamed to src/Completion/Async/PinyinAsyncCompletionSource.cs src/PinyinAsyncCompletionSource.cs renamed to src/Completion/Async/PinyinAsyncCompletionSource.cs

@@ -13,35 +13,27 @@
 using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion;
 using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data;
 using Microsoft.VisualStudio.Text;
-using Microsoft.VisualStudio.Utilities;
 
-namespace ChinesePinyinIntelliSenseExtender;
+namespace ChinesePinyinIntelliSenseExtender.Completion.Async;
 
-internal class PinyinAsyncCompletionSource : IAsyncCompletionSource
+internal class PinyinAsyncCompletionSource : CompletionSourceBase, IAsyncCompletionSource
 {
     #region Private 字段
 
     private static readonly CompletionFilter s_chineseFilter = new("中文代码", "C", new(KnownMonikers.Attribute.ToImageId(), "中文代码"));
 
     private static readonly ImmutableArray<CompletionFilter> s_chineseFilters = ImmutableArray.Create(s_chineseFilter);
 
-    /// <summary>
-    /// <see cref="GetCompletionContextAsync(IAsyncCompletionSession, CompletionTrigger, SnapshotPoint, SnapshotSpan, CancellationToken)"/> 递归标记
-    /// </summary>
-    private static readonly AsyncLocal<bool> s_getCompletionContextRecursionTag = new();
-
-    private readonly GeneralOptions _options;
     private readonly IEnumerable<IAsyncCompletionSource> _otherAsyncCompletionSources;
-    private InputMethodDictionaryGroup? _inputMethodDictionaryGroup;
 
     #endregion Private 字段
 
     #region Public 构造函数
 
     public PinyinAsyncCompletionSource(IEnumerable<IAsyncCompletionSource> otherAsyncCompletionSources, GeneralOptions options)
+        : base(options)
     {
         _otherAsyncCompletionSources = otherAsyncCompletionSources ?? throw new ArgumentNullException(nameof(otherAsyncCompletionSources));
-        _options = options ?? throw new ArgumentNullException(nameof(options));
     }
 
     #endregion Public 构造函数
@@ -50,32 +42,34 @@ public PinyinAsyncCompletionSource(IEnumerable<IAsyncCompletionSource> otherAsyn
 
     public async Task<CompletionContext?> GetCompletionContextAsync(IAsyncCompletionSession session, CompletionTrigger trigger, SnapshotPoint triggerLocation, SnapshotSpan applicableToSpan, CancellationToken token)
     {
-        if (s_getCompletionContextRecursionTag.Value
-            || !_options.Enable)
+        if (CanNotProcess())
         {
             return null;
         }
 
         try
         {
-            s_getCompletionContextRecursionTag.Value = true;
+            s_completionContextRecursionTag.Value = true;
 
-            if (_inputMethodDictionaryGroup is null
-                || _inputMethodDictionaryGroup.IsDisposed)
-            {
-                _inputMethodDictionaryGroup = await InputMethodDictionaryGroupProvider.GetAsync();
-            }
+            var getInputMethodDictionaryGroupTask = GetInputMethodDictionaryGroupAsync();
 
             var tasks = _otherAsyncCompletionSources.Select(m => m.GetCompletionContextAsync(session, trigger, triggerLocation, applicableToSpan, token)).ToArray();
 
             await Task.WhenAll(tasks);
 
             token.ThrowIfCancellationRequested();
 
-            Func<string, bool> shouldProcessCheckDelegate = StringPreMatchUtil.GetPreCheckPredicate(_options.PreMatchType, _options.PreCheckRule);
+            Func<string, bool> shouldProcessCheckDelegate = StringPreMatchUtil.GetPreCheckPredicate(Options.PreMatchType, Options.PreCheckRule);
 
             var allCompletionItems = tasks.SelectMany(static m => m.Status == TaskStatus.RanToCompletion && m.Result?.Items is not null ? m.Result.Items.AsEnumerable() : Array.Empty<CompletionItem>());
 
+            if (!allCompletionItems.Any())
+            {
+                return null;
+            }
+
+            var inputMethodDictionaryGroup = await getInputMethodDictionaryGroupTask;
+
             var count = tasks.Sum(static m => m.Status == TaskStatus.RanToCompletion && m.Result?.Items is not null ? m.Result.Items.Length : 0);
 
             var itemBuffer = ArrayPool<CompletionItem>.Shared.Rent(count * 5);  //预留足够多的空间，避免字典过多导致的问题
@@ -84,7 +78,7 @@ public PinyinAsyncCompletionSource(IEnumerable<IAsyncCompletionSource> otherAsyn
                 int bufferIndex = 0;
                 allCompletionItems.AsParallel()
                                   .WithCancellation(token)
-                                  .ForAll(m => CreateCompletionItemWithConvertion(m, shouldProcessCheckDelegate, itemBuffer, ref bufferIndex));
+                                  .ForAll(m => CreateCompletionItemWithConvertion(m, inputMethodDictionaryGroup, shouldProcessCheckDelegate, itemBuffer, ref bufferIndex));
 
                 if (bufferIndex > 0)
                 {
@@ -99,7 +93,7 @@ public PinyinAsyncCompletionSource(IEnumerable<IAsyncCompletionSource> otherAsyn
         }
         finally
         {
-            s_getCompletionContextRecursionTag.Value = false;
+            s_completionContextRecursionTag.Value = false;
         }
     }
 
@@ -125,7 +119,7 @@ public CompletionStartData InitializeCompletion(CompletionTrigger trigger, Snaps
 
     #region impl
 
-    private void CreateCompletionItemWithConvertion(CompletionItem originCompletionItem, Func<string, bool> shouldProcessCheck, CompletionItem[] itemBuffer, ref int bufferIndex)
+    private void CreateCompletionItemWithConvertion(CompletionItem originCompletionItem, InputMethodDictionaryGroup inputMethodDictionaryGroup, Func<string, bool> shouldProcessCheck, CompletionItem[] itemBuffer, ref int bufferIndex)
     {
         var originInsertText = originCompletionItem.InsertText;
 
@@ -134,28 +128,28 @@ private void CreateCompletionItemWithConvertion(CompletionItem originCompletionI
             return;
         }
 
-        var spellings = _inputMethodDictionaryGroup!.FindAll(originInsertText);
+        var spellings = inputMethodDictionaryGroup.FindAll(originInsertText);
 
         if (spellings.Length == 0)
         {
             return;
         }
 
-        if (_options.EnableFSharpSupport
+        if (Options.EnableFSharpSupport
             && originCompletionItem.Properties.TryGetProperty("RoslynCompletionItemData", out object data)
             && TryGetRoslynItemNameInCode(data, out var nameInCode))
         {
             originInsertText = nameInCode!;
         }
 
-        if (_options.SingleWordsDisplay)
+        if (Options.SingleWordsDisplay)
         {
             foreach (var spelling in spellings)
             {
                 itemBuffer[Interlocked.Increment(ref bufferIndex) - 1] = CreateCompletionItem(originCompletionItem, originInsertText, spelling);
             }
         }
-        else if (_options.EnableMultipleSpellings)
+        else if (Options.EnableMultipleSpellings)
         {
             itemBuffer[Interlocked.Increment(ref bufferIndex) - 1] = CreateCompletionItem(originCompletionItem, originInsertText, string.Join("/", spellings));
         }
@@ -169,11 +163,11 @@ private void CreateCompletionItemWithConvertion(CompletionItem originCompletionI
 
     private CompletionItem CreateCompletionItem(CompletionItem originCompletionItem, string originInsertText, string spelling)
     {
-        var newCompletionItem = new CompletionItem(displayText: Format(_options.DisplayTextFormat, originCompletionItem.DisplayText, spelling),
+        var newCompletionItem = new CompletionItem(displayText: FormatString(Options.DisplayTextFormat, originCompletionItem.DisplayText, spelling),
                                                    source: this,
                                                    icon: originCompletionItem.Icon,
                                                    filters: s_chineseFilters,
-                                                   suffix: Format(_options.DisplaySuffixFormat, originCompletionItem.Suffix, spelling),
+                                                   suffix: FormatString(Options.DisplaySuffixFormat, originCompletionItem.Suffix, spelling),
                                                    insertText: originInsertText,
                                                    sortText: spelling,
                                                    filterText: spelling,
@@ -187,23 +181,6 @@ private CompletionItem CreateCompletionItem(CompletionItem originCompletionItem,
         newCompletionItem.Properties.AddProperty(this, originCompletionItem);
 
         return newCompletionItem;
-
-        static string Format(string? format, string origin, string spellings)
-        {
-            if (string.IsNullOrEmpty(format))
-            {
-                return origin;
-            }
-            var builder = PooledStringBuilder.GetInstance();
-            try
-            {
-                return builder.Builder.AppendFormat(format, origin, spellings).ToString();
-            }
-            finally
-            {
-                builder.Free();
-            }
-        }
     }
 
     #endregion CreateCompletionItem

src/Completion/Async/PinyinAsyncCompletionSourceProvider.cs

@@ -0,0 +1,96 @@
+#nullable enable
+
+using System.ComponentModel.Composition;
+using System.Diagnostics;
+using System.Threading;
+
+using ChinesePinyinIntelliSenseExtender.Options;
+
+using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion;
+using Microsoft.VisualStudio.Language.Intellisense.AsyncCompletion.Data;
+using Microsoft.VisualStudio.Text;
+using Microsoft.VisualStudio.Text.Editor;
+using Microsoft.VisualStudio.Utilities;
+
+namespace ChinesePinyinIntelliSenseExtender.Completion.Async;
+
+[Export(typeof(IAsyncCompletionSourceProvider))]
+[Name("中文代码拼音补全")]
+[ContentType("text")]
+internal class PinyinAsyncCompletionSourceProvider : CompletionSourceProviderBase<ITextView, IAsyncCompletionSource>, IAsyncCompletionSourceProvider
+{
+    #region Private 字段
+
+    [ImportMany]
+    private readonly Lazy<IAsyncCompletionSourceProvider>[] _lazyAsyncCompletionSourceProviders = null!;
+
+    #endregion Private 字段
+
+    #region Public 方法
+
+    protected override IAsyncCompletionSource CreateCompletionSource(ITextView dependence)
+    {
+        var currentContentType = dependence.TextBuffer.ContentType;
+
+        var otherAsyncCompletionSources = _lazyAsyncCompletionSourceProviders
+            .Where(m => CheckShouldCreateCompletionSource(m.Value, currentContentType))
+            .Select(lazy =>
+            {
+                try
+                {
+                    return lazy.Value.GetOrCreate(dependence);
+                }
+                catch { }
+                return null;
+            })
+            .Where(m => m is not null)
+            .ToList()!;
+
+        Debug.WriteLine($"Total {otherAsyncCompletionSources?.Count ?? 0} IAsyncCompletionSource found.");
+
+        IAsyncCompletionSource completionSource = otherAsyncCompletionSources is null || otherAsyncCompletionSources.Count == 0
+                                                  ? EmptyAsyncCompletionSource.Instance
+                                                  : new PinyinAsyncCompletionSource(otherAsyncCompletionSources!, Options);
+
+        return completionSource;
+    }
+
+    protected override string? GetCurrentEditFilePath(ITextView dependence)
+    {
+        if (dependence.TextBuffer.Properties.TryGetProperty<ITextDocument>(typeof(ITextDocument), out var textDocument))
+        {
+            return textDocument?.FilePath;
+        }
+        return null;
+    }
+
+    protected override IAsyncCompletionSource GetDefaultCompletionSource(ITextView dependence)
+    {
+        return EmptyAsyncCompletionSource.Instance;
+    }
+
+    #endregion Public 方法
+
+    #region Private 类
+
+    private class EmptyAsyncCompletionSource : IAsyncCompletionSource
+    {
+        #region Public 属性
+
+        public static EmptyAsyncCompletionSource Instance { get; } = new();
+
+        #endregion Public 属性
+
+        #region Public 方法
+
+        public Task<CompletionContext> GetCompletionContextAsync(IAsyncCompletionSession session, CompletionTrigger trigger, SnapshotPoint triggerLocation, SnapshotSpan applicableToSpan, CancellationToken token) => Task.FromResult<CompletionContext>(null!);
+
+        public Task<object> GetDescriptionAsync(IAsyncCompletionSession session, CompletionItem item, CancellationToken token) => Task.FromResult<object>(null!);
+
+        public CompletionStartData InitializeCompletion(CompletionTrigger trigger, SnapshotPoint triggerLocation, CancellationToken token) => CompletionStartData.DoesNotParticipateInCompletion;
+
+        #endregion Public 方法
+    }
+
+    #endregion Private 类
+}

src/Completion/CompletionSourceBase.cs

@@ -0,0 +1,85 @@
+#nullable enable
+
+using System.Threading;
+
+using ChinesePinyinIntelliSenseExtender.Options;
+using ChinesePinyinIntelliSenseExtender.Util;
+using Microsoft.VisualStudio.Utilities;
+
+namespace ChinesePinyinIntelliSenseExtender.Completion;
+
+internal abstract class CompletionSourceBase
+{
+    #region Protected 字段
+
+    /// <summary>
+    /// 递归标记
+    /// </summary>
+    protected static readonly AsyncLocal<bool> s_completionContextRecursionTag = new();
+
+    protected readonly GeneralOptions Options;
+
+    #endregion Protected 字段
+
+    #region Private 字段
+
+    private InputMethodDictionaryGroup? _inputMethodDictionaryGroup;
+
+    #endregion Private 字段
+
+    #region Public 构造函数
+
+    public CompletionSourceBase(GeneralOptions options)
+    {
+        Options = options ?? throw new ArgumentNullException(nameof(options));
+    }
+
+    #endregion Public 构造函数
+
+    #region Protected 方法
+
+    protected static string FormatString(string? format, string origin, string spellings)
+    {
+        if (string.IsNullOrEmpty(format))
+        {
+            return origin;
+        }
+        var builder = PooledStringBuilder.GetInstance();
+        try
+        {
+            return builder.Builder.AppendFormat(format, origin, spellings).ToString();
+        }
+        finally
+        {
+            builder.Free();
+        }
+    }
+
+    protected bool CanNotProcess()
+    {
+        return s_completionContextRecursionTag.Value
+               || !Options.Enable;
+    }
+
+    protected InputMethodDictionaryGroup GetInputMethodDictionaryGroup()
+    {
+        if (_inputMethodDictionaryGroup is null
+            || _inputMethodDictionaryGroup.IsDisposed)
+        {
+            _inputMethodDictionaryGroup = InputMethodDictionaryGroupProvider.GetAsync().ConfigureAwait(false).GetAwaiter().GetResult();
+        }
+        return _inputMethodDictionaryGroup;
+    }
+
+    protected async Task<InputMethodDictionaryGroup> GetInputMethodDictionaryGroupAsync()
+    {
+        if (_inputMethodDictionaryGroup is null
+            || _inputMethodDictionaryGroup.IsDisposed)
+        {
+            _inputMethodDictionaryGroup = await InputMethodDictionaryGroupProvider.GetAsync();
+        }
+        return _inputMethodDictionaryGroup;
+    }
+
+    #endregion Protected 方法
+}