[jjonescz]

Fixes #85788.

Microsoft Reviewers: Open in CodeFlow

[azure-pipelines]

Azure Pipelines:
Successfully started running 2 pipeline(s).
There may be pipelines that require an authorized user to comment /azp run to run.

[Copilot]

Copilot review overview

🟢 Approval recommended

The focused compiler fix matches existing cref semantics and has strong regression coverage.

Review effort: Balanced
Findings: None

What changed in this PR

Prevents cref completion crashes by excluding unsupported reduced-extension lookup for cref type parameters.

Changes:

• Guard cref type parameters during symbol lookup.
• Add compiler and completion regression coverage.

File	Description
CSharpSemanticModel.cs	Skips reduced-extension lookup for cref type parameters.
CrefTests.cs	Tests classic and block extension lookup behavior.
CrefCompletionProviderTests.cs	Verifies completion descriptions no longer crash.

[akhera99]

whoops forgot to tag the issue in my PR: #85817

but I like your fix better

[AlekseyTs]

container is TypeParameterSymbol { TypeParameterKind: TypeParameterKind.Cref }

The change prevents a crash for the tested scenario. But I think that it is better to implement unimplemented APIs on CrefTypeParameterSymbol. For example, return ErrorTypeSymbol.UnknownResultType; works for the scenario.
Also, we can end up here with a generic type symbol constructed with such type parameter as a type argument. And quite possibly an attempt might be made to use one of the "unimplemented" APIs while classifying conversion for that type. For example, the following unit-test does:

        [Fact]
        [WorkItem("[https://github.com/dotnet/roslyn/issues/85788](https://github.com/dotnet/roslyn/issues/85788)")]
        public void CrefTypeParameterExtensionMemberLookup1()
        {
            var source = """
                interface I<out T>
                {
                    public I<T> Copy1();
                }

                /// <see cref="I{U}.Copy1()"/>
                class D { }
                """;
            var extensions = """
                static class Extensions
                {
                    extension(I<D> value)
                    {
                        public int Copy2() => 0;
                    }
                }
                """;

            var compilation = CreateCompilation([source, extensions], parseOptions: TestOptions.RegularWithDocumentationComments);
            compilation.VerifyEmitDiagnostics();

            var cref = GetCrefSyntaxes(compilation).Single();
            var model = compilation.GetSemanticModel(cref.SyntaxTree);
            var method = (IMethodSymbol)model.GetSymbolInfo(cref).Symbol;
            var type = (INamedTypeSymbol)method.ReturnType;
            Assert.Equal(TypeParameterKind.Cref, ((ITypeParameterSymbol)(type.TypeArguments[0])).TypeParameterKind);

            Assert.Empty(model.LookupSymbols(cref.SpanStart, type, "Copy2", includeReducedExtensionMethods: true));
        }

There is no crash for this scenario, but there is an attempt to classify conversion for cref type parameter.

Bottom line, I think it will be much better to implement the APIs in some reasonable way. #Closed

[AlekseyTs]

Done with review pass (commit 1)

[Copilot]

Copilot review overview

🟢 Approval recommended

The focused fix is conservative and has comprehensive regression coverage.

Review effort: Balanced
Findings: None

[AlekseyTs]

LGTM (commit 2)