Fix 'ctor' snippet in nested class

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/Snippets/CSharpConstructorSnippetCompletionProviderTests.cs

@@ -168,5 +168,116 @@ public MyClass1()
 }";
             await VerifyCustomCommitProviderAsync(markupBeforeCommit, ItemToCommit, expectedCodeAfterCommit);
         }
+
+        [WpfTheory]
+        [InlineData("class")]
+        [InlineData("enum")]
+        [InlineData("interface")]
+        [InlineData("record")]
+        [InlineData("struct")]
+        [InlineData("record class")]
+        [InlineData("record struct")]
+        [Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertConstructorSnippetHasNestedTypeTest(string keyword)
+        {
+            var markupBeforeCommit =
+$$"""
+class Outer
+{
+    $$
+    {{keyword}} Inner
+    {
+    }
+}
+""";
+
+            var expectedCodeAfterCommit =
+$$"""
+class Outer
+{
+    public Outer()
+    {
+        $$
+    }
+    {{keyword}} Inner
+    {
+    }
+}
+""";
+
+            await VerifyCustomCommitProviderAsync(markupBeforeCommit, ItemToCommit, expectedCodeAfterCommit);
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertConstructorSnippetHasNestedClassGluedOuterTest()
+        {
+            var markupBeforeCommit_GluedToOuter =
+@"class Outer
+{$$
+    class Inner
+    {
+    }
+}";
+            // The position ($$) is in a strange position because code does not format after insertion.
+            var expectedCodeAfterCommit_GluedToOuter =
+@"class Outer
+{    public Outer()
+    {
+
+$$    }
+    class Inner
+    {
+    }
+}";
+            await VerifyCustomCommitProviderAsync(markupBeforeCommit_GluedToOuter, ItemToCommit, expectedCodeAfterCommit_GluedToOuter);
+        }
+
+        [WpfTheory]
+        [InlineData("class")]
+        [InlineData("record")]
+        [InlineData("struct")]
+        [InlineData("record class")]
+        [InlineData("record struct")]
+        [Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertConstructorSnippetInConstructableTypeTest(string keyword)
+        {
+            var markupBeforeCommit =
+$$"""
+{{keyword}} MyName
+{
+    $$
+}
+""";
+
+            var expectedCodeAfterCommit =
+$$"""
+{{keyword}} MyName
+{
+    public MyName()
+    {
+        $$
+    }
+}
+""";
+
+            await VerifyCustomCommitProviderAsync(markupBeforeCommit, ItemToCommit, expectedCodeAfterCommit);
+        }
+
+        [WpfTheory]
+        [InlineData("enum")]
+        [InlineData("interface")]
+        [Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InsertConstructorSnippetInNotConstructableTypeTest(string keyword)
+        {
+            var markupBeforeCommit =
+$$"""
+{{keyword}} MyName
+{
+    $$
+}
+""";
+
+            await VerifyItemIsAbsentAsync(markupBeforeCommit, ItemToCommit);
+        }
     }
 }

src/Features/CSharp/Portable/Snippets/CSharpConstructorSnippetProvider.cs

@@ -93,5 +93,11 @@ protected override async Task<Document> AddIndentationToDocumentAsync(Document d
             var newRoot = root.ReplaceNode(constructorDeclaration, newConstructorDeclaration);
             return document.WithSyntaxRoot(newRoot);
         }
+
+        protected override bool IsConstructableTypeDeclaration(ISyntaxFacts syntaxFacts, SyntaxNode node)
+        {
+            return syntaxFacts.IsTypeDeclaration(node)
+                && SyntaxKindSet.ClassStructRecordTypeDeclarations.Contains(node.Kind());
+        }
     }
 }

src/Features/Core/Portable/Snippets/SnippetProviders/AbstractConstructorSnippetProvider.cs

@@ -32,12 +32,25 @@ protected override async Task<TextChange> GenerateSnippetTextChangeAsync(Documen
             var syntaxFacts = document.GetRequiredLanguageService<ISyntaxFactsService>();
             var root = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var nodeAtPosition = root.FindNode(TextSpan.FromBounds(position, position));
-            var containingType = nodeAtPosition.FirstAncestorOrSelf<SyntaxNode>(syntaxFacts.IsTypeDeclaration);
+
+            // Skip inner class in nested class if position is out of it.
+            //     For example "class Outer{\r\n ctor@ \r\n class Inner {} }"
+            // Accept even if "static class" (CS0710).
+            var containingType = nodeAtPosition.FirstAncestorOrSelf<SyntaxNode>((node) =>
+            {
+                return syntaxFacts.IsTypeDeclaration(node)
+                    && IsConstructableTypeDeclaration(syntaxFacts, node)
+                    && node.Span.Contains(position);
+            });
+
             Contract.ThrowIfNull(containingType);
             var constructorDeclaration = generator.ConstructorDeclaration(
                 containingTypeName: syntaxFacts.GetIdentifierOfTypeDeclaration(containingType).ToString(),
                 accessibility: Accessibility.Public);
             return new TextChange(TextSpan.FromBounds(position, position), constructorDeclaration.NormalizeWhitespace().ToFullString());
         }
+
+        // Move this to ISyntaxFacts if approved.
+        protected abstract bool IsConstructableTypeDeclaration(ISyntaxFacts syntaxFacts, SyntaxNode node);
     }
 }