Don't add parenthesis when committing type with accessible nested type using dot (#80846)

fix #78515,
#51629

Author: genlu

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

@@ -13621,4 +13621,47 @@ private static string MakeMarkup(
 
     public static IEnumerable<object[]> ValidEnumUnderlyingTypeNames()
         => [["Byte"], ["SByte"], ["Int16"], ["UInt16"], ["Int32"], ["UInt32"], ["Int64"], ["UInt64"]];
+
+    [Theory, CombinatorialData]
+    public Task CompletionInObjectCreationContextForTypeWithNestedTypes(
+        [CombinatorialValues(".", ";")] char commitChar,
+        [CombinatorialValues("public", "private", "internal", "")] string modifier)
+    {
+        // always add "()" if committed via ";", or when nested types are inaccessible if via "."
+        var parens = commitChar is ';'
+            ? "()"
+            : modifier is "private" or ""
+                ? "()"
+                : "";
+
+        return VerifyProviderCommitAsync($$"""
+            class Program
+            {
+                void M()
+                {
+                    var a = new Ba$$
+                }
+            }
+
+            class Bar
+            {
+                {{modifier}} class Foo1 { }
+                class Foo2 { }
+            }
+            """, "Bar", $$"""
+            class Program
+            {
+                void M()
+                {
+                    var a = new Bar{{parens}}{{commitChar}}
+                }
+            }
+
+            class Bar
+            {
+                {{modifier}} class Foo1 { }
+                class Foo2 { }
+            }
+            """, commitChar: commitChar, sourceCodeKind: SourceCodeKind.Regular);
+    }
 }

src/Features/CSharp/Portable/Completion/CompletionProviders/SymbolCompletionProvider.cs

@@ -254,25 +254,65 @@ protected override CompletionItem CreateItem(
                 item = SymbolCompletionItem.AddShouldProvideParenthesisCompletion(item);
             }
         }
-        else if (symbol.IsKind(SymbolKind.NamedType) || symbol is IAliasSymbol aliasSymbol && aliasSymbol.Target.IsType)
+        else if (context.IsObjectCreationTypeContext)
         {
             // If this is a type symbol/alias symbol, also consider appending parenthesis when later, it is committed by using special characters,
             // and the type is used as constructor
-            if (context.IsObjectCreationTypeContext)
+            var typeSymbol = symbol as INamedTypeSymbol ?? (symbol as IAliasSymbol)?.Target as INamedTypeSymbol;
+            if (typeSymbol is not null)
+            {
                 item = SymbolCompletionItem.AddShouldProvideParenthesisCompletion(item);
+
+                // When committing with `.`, we don't want to automatically appending parenthesis for types
+                // that has accessible nested types (user might want to access nested types like Bar.Foo)
+                if (HasAccessibleNestedTypes(typeSymbol))
+                {
+                    item = SymbolCompletionItem.AddHasAccessibleNestedTypes(item);
+                }
+            }
         }
 
         return item;
+
+        bool HasAccessibleNestedTypes(INamedTypeSymbol typeSymbol)
+        {
+            // This is intended to be a heuristic to cover common cases.
+            // Because we might be passed a speculative member semantic model, we won't be able to get
+            // symbols for containing type/member symbol to check accessibility using `IsAccessibleWithin`.
+            // While this check is inaccurate in some cases (e.g. from within nested/derived types),
+            // it's likely fine because people typically don't access the nested types via the outer one
+            // when they are within the inner or derived type.
+            foreach (var typeMember in typeSymbol.GetTypeMembers())
+            {
+                if (typeMember.DeclaredAccessibility <= Accessibility.Protected)
+                    continue;
+
+                if (typeMember.DeclaredAccessibility is Accessibility.Public)
+                    return true;
+
+                if (typeMember.IsAccessibleWithin(context.SemanticModel.Compilation.Assembly))
+                    return true;
+            }
+
+            return false;
+        }
     }
 
     protected override string GetInsertionText(CompletionItem item, char ch)
     {
-        if (ch is ';' or '.' && SymbolCompletionItem.GetShouldProvideParenthesisCompletion(item))
+        if (SymbolCompletionItem.GetShouldProvideParenthesisCompletion(item))
         {
-            CompletionProvidersLogger.LogCustomizedCommitToAddParenthesis(ch);
-            return SymbolCompletionItem.GetInsertionText(item) + "()";
+            // For '.', don't add parentheses if the type has accessible nested types
+            // (user might want to access nested types like Bar.Foo)
+            if (ch is ';' ||
+                ch is '.' && !SymbolCompletionItem.GetHasAccessibleNestedTypes(item))
+            {
+                CompletionProvidersLogger.LogCustomizedCommitToAddParenthesis(ch);
+                return SymbolCompletionItem.GetInsertionText(item) + "()";
+            }
         }
 
         return base.GetInsertionText(item, ch);
     }
 }
+

src/Features/Core/Portable/Completion/Providers/SymbolCompletionItem.cs

@@ -104,6 +104,12 @@ public static bool GetShouldProvideParenthesisCompletion(CompletionItem item)
         return false;
     }
 
+    public static CompletionItem AddHasAccessibleNestedTypes(CompletionItem item)
+        => item.AddProperty("HasAccessibleNestedTypes", true.ToString());
+
+    public static bool GetHasAccessibleNestedTypes(CompletionItem item)
+        => item.TryGetProperty("HasAccessibleNestedTypes", out _);
+
     public static string EncodeSymbols(ImmutableArray<ISymbol> symbols)
     {
         if (symbols.Length > 1)