Restore original fix for #2639

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

@@ -7235,6 +7235,143 @@ class MyAttribute : Attribute
             VerifyItemExists(markup, "My");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public void InstanceMembersFromBaseOuterType()
+        {
+            var markup = @"abstract class Test
+{
+  private int _field;
+
+  public sealed class InnerTest : Test 
+  {
+    
+    public void SomeTest() 
+    {
+        $$
+    }
+  }
+}";
+            VerifyItemExists(markup, "_field");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public void InstanceMembersFromBaseOuterType2()
+        {
+            var markup = @"class C<T>
+{
+    void M() { }
+    class N : C<int>
+    {
+        void Test()
+        {
+            $$ // M recommended and accessible
+        }
+
+        class NN
+        {
+            void Test2()
+            {
+                // M inaccessible and not recommended
+            }
+        }
+    }
+}";
+            VerifyItemExists(markup, "M");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public void InstanceMembersFromBaseOuterType3()
+        {
+            var markup = @"class C<T>
+{
+    void M() { }
+    class N : C<int>
+    {
+        void Test()
+        {
+            M(); // M recommended and accessible
+        }
+
+        class NN
+        {
+            void Test2()
+            {
+                $$ // M inaccessible and not recommended
+            }
+        }
+    }
+}";
+            VerifyItemIsAbsent(markup, "M");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public void InstanceMembersFromBaseOuterType4()
+        {
+            var markup = @"class C<T>
+{
+    void M() { }
+    class N : C<int>
+    {
+        void Test()
+        {
+            M(); // M recommended and accessible
+        }
+
+        class NN : N
+        {
+            void Test2()
+            {
+                $$ // M accessible and recommended.
+            }
+        }
+    }
+}";
+            VerifyItemExists(markup, "M");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public void InstanceMembersFromBaseOuterType5()
+        {
+            var markup = @"
+class D
+{
+    public void Q() { }
+}
+class C<T> : D
+{
+    class N
+    {
+        void Test()
+        {
+            $$
+        }
+    }
+}";
+            VerifyItemIsAbsent(markup, "Q");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public void InstanceMembersFromBaseOuterType6()
+        {
+            var markup = @"
+class Base<T>
+{
+    public int X;
+}
+
+class Derived : Base<int>
+{
+    class Nested
+    {
+        void Test()
+        {
+            $$
+        }
+    }
+}";
+            VerifyItemIsAbsent(markup, "X");
+        }
+
         [WorkItem(983367)]
         [Fact, Trait(Traits.Feature, Traits.Features.Completion)]
         public void NoTypeParametersDefinedInCrefs()

src/Workspaces/Core/Portable/Recommendations/AbstractRecommendationService.cs

@@ -79,10 +79,15 @@ private bool ShouldIncludeSymbol(ISymbol symbol, AbstractSyntaxContext context,
             // In an expression or statement context, we don't want to display instance members declared in outer containing types.
             if ((context.IsStatementContext || context.IsAnyExpressionContext) &&
                 !symbol.IsStatic &&
-                isMember &&
-                context.GetOuterTypes(cancellationToken).Contains(symbol.ContainingType))
+                isMember)
             {
-                return false;
+                var outerTypesAndBases = context.GetOuterTypes(cancellationToken).SelectMany(o => o.GetBaseTypesAndThis()).Select(t => t.OriginalDefinition);
+                var containingTypeOriginalDefinition = symbol.ContainingType.OriginalDefinition;
+                if (outerTypesAndBases.Contains(containingTypeOriginalDefinition))
+                {
+                    var enclosingType = context.SemanticModel.GetEnclosingNamedType(context.LeftToken.SpanStart, cancellationToken);
+                    return enclosingType != null && enclosingType.GetBaseTypes().Select(b => b.OriginalDefinition).Contains(containingTypeOriginalDefinition);
+                }
             }
 
             var namespaceSymbol = symbol as INamespaceSymbol;