Support EditorBrowsable in completion for unimported types

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/TypeImportCompletionProviderTests.cs

@@ -13,7 +13,6 @@
 using Microsoft.CodeAnalysis.Experiments;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Test.Utilities;
-using Microsoft.VisualStudio.Composition;
 using Roslyn.Test.Utilities;
 using Xunit;
 
@@ -35,12 +34,15 @@ internal override Type GetCompletionProviderType()
 
         private bool DisallowAddingImports { get; set; }
 
+        private bool HideAdvancedMembers { get; set; }
+
         protected override OptionSet WithChangedOptions(OptionSet options)
         {
             return options
                 .WithChangedOption(CompletionOptions.ShowItemsFromUnimportedNamespaces, LanguageNames.CSharp, ShowImportCompletionItemsOptionValue)
                 .WithChangedOption(CompletionServiceOptions.IsExpandedCompletion, IsExpandedCompletion)
-                .WithChangedOption(CompletionServiceOptions.DisallowAddingImports, DisallowAddingImports);
+                .WithChangedOption(CompletionServiceOptions.DisallowAddingImports, DisallowAddingImports)
+                .WithChangedOption(CompletionOptions.HideAdvancedMembers, LanguageNames.CSharp, HideAdvancedMembers);
         }
 
         protected override TestComposition GetComposition()
@@ -1413,6 +1415,138 @@ private static void AssertRelativeOrder(List<string> expectedTypesInRelativeOrde
             }
         }
 
+        [InlineData(true)]
+        [InlineData(false)]
+        [Theory, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task TestBrowsableAwaysFromReferences(bool isProjectReference)
+        {
+            var srcDoc = @"
+class Program
+{
+    void M()
+    {
+        $$
+    }
+}";
+
+            var refDoc = @"
+namespace Foo
+{
+    [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Always)]
+    public class Goo
+    {
+    }
+}";
+
+            var markup = isProjectReference switch
+            {
+                true => CreateMarkupForProjectWithProjectReference(srcDoc, refDoc, LanguageNames.CSharp, LanguageNames.CSharp),
+                false => CreateMarkupForProjectWithMetadataReference(srcDoc, refDoc, LanguageNames.CSharp, LanguageNames.CSharp)
+            };
+
+            await VerifyTypeImportItemExistsAsync(
+                    markup,
+                    "Goo",
+                    glyph: (int)Glyph.ClassPublic,
+                    inlineDescription: "Foo");
+        }
+
+        [InlineData(true)]
+        [InlineData(false)]
+        [Theory, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task TestBrowsableNeverFromReferences(bool isProjectReference)
+        {
+            var srcDoc = @"
+class Program
+{
+    void M()
+    {
+        $$
+    }
+}";
+
+            var refDoc = @"
+namespace Foo
+{
+    [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Never)]
+    public class Goo
+    {
+    }
+}";
+
+            var (markup, shouldContainItem) = isProjectReference switch
+            {
+                true => (CreateMarkupForProjectWithProjectReference(srcDoc, refDoc, LanguageNames.CSharp, LanguageNames.CSharp), true),
+                false => (CreateMarkupForProjectWithMetadataReference(srcDoc, refDoc, LanguageNames.CSharp, LanguageNames.CSharp), false),
+            };
+
+            if (shouldContainItem)
+            {
+                await VerifyTypeImportItemExistsAsync(
+                        markup,
+                        "Goo",
+                        glyph: (int)Glyph.ClassPublic,
+                        inlineDescription: "Foo");
+            }
+            else
+            {
+                await VerifyTypeImportItemIsAbsentAsync(
+                        markup,
+                        "Goo",
+                        inlineDescription: "Foo");
+            }
+        }
+
+        [InlineData(true, true)]
+        [InlineData(true, false)]
+        [InlineData(false, true)]
+        [InlineData(false, false)]
+        [Theory, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task TestBrowsableAdvancedFromReferences(bool isProjectReference, bool hideAdvancedMembers)
+        {
+            HideAdvancedMembers = hideAdvancedMembers;
+
+            var srcDoc = @"
+class Program
+{
+    void M()
+    {
+        $$
+    }
+}";
+
+            var refDoc = @"
+namespace Foo
+{
+    [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
+    public class Goo
+    {
+    }
+}";
+
+            var (markup, shouldContainItem) = isProjectReference switch
+            {
+                true => (CreateMarkupForProjectWithProjectReference(srcDoc, refDoc, LanguageNames.CSharp, LanguageNames.CSharp), true),
+                false => (CreateMarkupForProjectWithMetadataReference(srcDoc, refDoc, LanguageNames.CSharp, LanguageNames.CSharp), !hideAdvancedMembers),
+            };
+
+            if (shouldContainItem)
+            {
+                await VerifyTypeImportItemExistsAsync(
+                        markup,
+                        "Goo",
+                        glyph: (int)Glyph.ClassPublic,
+                        inlineDescription: "Foo");
+            }
+            else
+            {
+                await VerifyTypeImportItemIsAbsentAsync(
+                        markup,
+                        "Goo",
+                        inlineDescription: "Foo");
+            }
+        }
+
         private Task VerifyTypeImportItemExistsAsync(string markup, string expectedItem, int glyph, string inlineDescription, string displayTextSuffix = null, string expectedDescriptionOrNull = null, CompletionItemFlags? flags = null)
             => VerifyItemExistsAsync(markup, expectedItem, displayTextSuffix: displayTextSuffix, glyph: glyph, inlineDescription: inlineDescription, expectedDescriptionOrNull: expectedDescriptionOrNull, flags: flags);
 

src/Features/Core/Portable/Completion/Providers/ImportCompletionProvider/AbstractTypeImportCompletionService.CacheEntry.cs

@@ -25,31 +25,40 @@ private readonly struct CacheEntry
 
             private ImmutableArray<TypeImportCompletionItemInfo> ItemInfos { get; }
 
+            public bool ContainsAdvancedMembers { get; }
+
             private CacheEntry(
                 Checksum checksum,
                 string language,
+                bool containsAdvancedmembers,
                 ImmutableArray<TypeImportCompletionItemInfo> items)
             {
                 Checksum = checksum;
                 Language = language;
 
+                ContainsAdvancedMembers = containsAdvancedmembers;
                 ItemInfos = items;
+
             }
 
             public ImmutableArray<CompletionItem> GetItemsForContext(
                 string language,
                 string genericTypeSuffix,
                 bool isInternalsVisible,
                 bool isAttributeContext,
-                bool isCaseSensitive)
+                bool isCaseSensitive,
+                bool hideAdvancedMembers)
             {
                 // We will need to adjust some items if the request is made in:
                 // 1. attribute context, then we will not show or complete with "Attribute" suffix.
                 // 2. a project with different language than when the cache entry was created,
                 //    then we will change the generic suffix accordingly.
+                // 3. asked to hide advanced members and there is advanced member in the cache
                 // Otherwise, we can simply return cached items.
                 var isSameLanguage = Language == language;
-                if (isSameLanguage && !isAttributeContext)
+                if (isSameLanguage &&
+                    !isAttributeContext &&
+                    !(hideAdvancedMembers && ContainsAdvancedMembers))
                 {
                     return ItemInfos.Where(info => info.IsPublic || isInternalsVisible).SelectAsArray(info => info.Item);
                 }
@@ -59,6 +68,11 @@ public ImmutableArray<CompletionItem> GetItemsForContext(
                 {
                     if (info.IsPublic || isInternalsVisible)
                     {
+                        if (hideAdvancedMembers && info.IsEditorBrowsableStateAdvanced)
+                        {
+                            continue;
+                        }
+
                         var item = info.Item;
                         if (isAttributeContext)
                         {
@@ -99,14 +113,18 @@ public class Builder : IDisposable
                 private readonly string _language;
                 private readonly string _genericTypeSuffix;
                 private readonly Checksum _checksum;
+                private readonly EditorBrowsableInfo _editorBrowsableInfo;
 
                 private readonly ArrayBuilder<TypeImportCompletionItemInfo> _itemsBuilder;
 
-                public Builder(Checksum checksum, string language, string genericTypeSuffix)
+                private bool _containsAdvancedMembers;
+
+                public Builder(Checksum checksum, string language, string genericTypeSuffix, EditorBrowsableInfo editorBrowsableInfo)
                 {
                     _checksum = checksum;
                     _language = language;
                     _genericTypeSuffix = genericTypeSuffix;
+                    _editorBrowsableInfo = editorBrowsableInfo;
 
                     _itemsBuilder = ArrayBuilder<TypeImportCompletionItemInfo>.GetInstance();
                 }
@@ -116,11 +134,28 @@ public CacheEntry ToReferenceCacheEntry()
                     return new CacheEntry(
                         _checksum,
                         _language,
+                        _containsAdvancedMembers,
                         _itemsBuilder.ToImmutable());
                 }
 
                 public void AddItem(INamedTypeSymbol symbol, string containingNamespace, bool isPublic)
                 {
+                    // We want to cache items with EditoBrowsableState == Advanced regarless of current "hide adv members" option value
+                    var (isBrowsable, isEditorBrowsableStateAdvanced) = symbol.IsEditorBrowsableWithState(
+                        hideAdvancedMembers: false,
+                        _editorBrowsableInfo.Compilation,
+                        _editorBrowsableInfo.EditorBrowsableAttributeConstructor,
+                        _editorBrowsableInfo.TypeLibTypeAttributeConstructors,
+                        _editorBrowsableInfo.TypeLibFuncAttributeConstructors,
+                        _editorBrowsableInfo.TypeLibVarAttributeConstructors,
+                        _editorBrowsableInfo.HideModuleNameAttribute);
+
+                    if (!isBrowsable)
+                    {
+                        // Hide this item from completion
+                        return;
+                    }
+
                     var isGeneric = symbol.Arity > 0;
 
                     // Need to determine if a type is an attribute up front since we want to filter out 
@@ -140,7 +175,8 @@ public void AddItem(INamedTypeSymbol symbol, string containingNamespace, bool is
                         CompletionItemFlags.CachedAndExpanded,
                         extensionMethodData: null);
 
-                    _itemsBuilder.Add(new TypeImportCompletionItemInfo(item, isPublic, isGeneric, isAttribute));
+                    _containsAdvancedMembers = _containsAdvancedMembers || isEditorBrowsableStateAdvanced;
+                    _itemsBuilder.Add(new TypeImportCompletionItemInfo(item, isPublic, isGeneric, isAttribute, isEditorBrowsableStateAdvanced));
                 }
 
                 public void Dispose()