Extension indexers: allow and resolve extension indexers #81607

jcouv · 2025-12-09T21:05:10Z

The main changes in this PR:

addition of TryBindExtensionIndexer
add new feature IDS_FeatureExtensionIndexers and check LangVer (declarations and usages, see CheckExtensionMembers and ReportDiagnosticsIfDisallowedExtensionIndexer)
round-tripping of indexers in metadata: emit DefaultMemberAttribute on grouping type, which contains the extension indexer(s)
simplify RefSafetyAnalysis.MethodInfo and fix analysis of assignments

Identified some follow-ups around nullability, CREF binding, GetMemberGroup, "countable" properties, interpolation handlers, improving diagnostic quality, an existing crash with a method named this[] in metadata.

The usages of extension indexers: element access, null-conditional indexing and assignment, list and spread pattern, and object initializer.

Corresponding spec is ~~incoming~~ here. Some notable choices (will confirm with LDM):

extension indexers come before implicit indexers
no extension indexers on base

Fixes #81796 which was opened for tracking purpose

Relates to test plan #81505

AlekseyTs · 2025-12-10T17:09:37Z

It looks like the speclet says nothing about consumption scenarios #Closed

jcouv · 2025-12-10T17:25:47Z

It looks like the speclet says nothing about consumption scenarios

Yes, the speclet was not yet updated.

Corresponding spec is incoming. Some notable choices (will confirm with LDM):

extension indexers come before implicit indexers

no extension indexers on base

AlekseyTs · 2025-12-10T17:44:05Z

src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs

+                    if (member is PropertySymbol)
+                    {
+                        diagnostics.Add(new CSDiagnostic(
+                            new CSDiagnosticInfo(ErrorCode.ERR_ExtensionDisallowsIndexerMember, new CSharpRequiredLanguageVersion(MessageID.IDS_FeatureExtensionIndexers.RequiredVersion())),


new CSDiagnosticInfo(ErrorCode.ERR_ExtensionDisallowsIndexerMember, new CSharpRequiredLanguageVersion(MessageID.IDS_FeatureExtensionIndexers.RequiredVersion())),

I think we can use regular language version error here #Closed

AlekseyTs · 2025-12-10T17:45:52Z

src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs

+                if (!IsAllowedExtensionMember(member, languageVersion))
                {
-                    diagnostics.Add(ErrorCode.ERR_ExtensionDisallowsMember, member.GetFirstLocation());
+                    if (member is PropertySymbol)


member is PropertySymbol

It looks like we are assuming that this is an indexer. Consider asserting the fact, or including this as a condition. #Closed

AlekseyTs · 2025-12-10T17:47:16Z

src/Compilers/CSharp/Portable/CSharpResources.resx

+  <data name="IDS_FeatureExtensionIndexers" xml:space="preserve">
+    <value>extension indexers</value>
+  </data>
+  <data name="ERR_ExtensionDisallowsIndexerMember" xml:space="preserve">


ERR_ExtensionDisallowsIndexerMember

It doesn't look like it is necessary to have this error, a regular language version error for the feature would work as good. #Closed

AlekseyTs · 2025-12-10T18:01:56Z

src/Compilers/CSharp/Portable/Binder/Binder.cs


+        internal static void ReportDiagnosticsIfDisallowedExtensionIndexer(BindingDiagnosticBag diagnostics, PropertySymbol property, SyntaxNode syntax)
+        {
+            if (property.IsExtensionBlockMember())


property

How do we know that this is an indexer? #Closed

AlekseyTs · 2025-12-10T18:06:01Z

src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs

                var setMethod = replace(SetMethod);
                Symbol symbol = ReferenceEquals(Symbol, Method) && method is not null ? method : Symbol;

-                Debug.Assert(SetMethod?.IsExtensionBlockMember() != true);


Debug.Assert(SetMethod?.IsExtensionBlockMember() != true);

It is not obvious why this condition was correct for properties and isn't for indexers. Is it still worth asserting for properties? #Closed

We analyze the invocation for property access and indexer access in VisitPropertyAccess, VisitIndexerAccess and VisitAssignmentOperator.
In VisitPropertyAccess there is no argument mixing to analyze.
In VisitAssignmentOperator we only analyze the setter (so Method is set, but SetMethod isn't).
This PR added argument mixing handling to VisitIndexerAccess, which is the first time we'd hit this logic with extension member get and set both used.

I have to say I found this Method/SetMethod design confusing. So I made a separate commit that simplifies this design by removing SetMethod. For a given scenario, we can always analyze arg mixing for one specific method, we don't need two.
After that change, we analyze the getter invocation in VisitIndexerAccess (when a getter is involved) and we analyze the setter invocation in VisitAssignmentOperator (which we were already doing previously, but only for extension members).
The only downside is that for certain operations (increment operator) we now report two sets of diagnostics: one for the getter and one for the setter, so there's a bit of redundancy. I think that's okay, but I could leave a PROTOTYPE to further refine if you want.
This also fixed spurious diagnostics (see removed diagnostics in RefEscapingTests.cs

AlekseyTs · 2025-12-10T19:28:06Z

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

+                    lookupResult, WellKnownMemberNames.Indexer, arity: 0, LookupOptions.AllMethodsOnArityZero,
+                    originalBinder: binder, useSiteInfo: ref useSiteInfo);
+
+                if (!lookupResult.IsMultiViable || lookupResult.Symbols.All(s => s.Kind != SymbolKind.Property))


s.Kind != SymbolKind.Property

Should we also check that it is an indexer? #Closed

AlekseyTs · 2025-12-10T19:32:31Z

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

+
+                MemberResolutionResult<PropertySymbol> resolutionResult = result.ValidResult;
+                Debug.Assert(resolutionResult.Result.ConversionForArg(0).Exists);
+                resolutionResult = resolutionResult.WithResult(resolutionResult.Result.WithoutReceiverArgument());


resolutionResult = resolutionResult.WithResult(resolutionResult.Result.WithoutReceiverArgument());

Since we are dropping receiver argument, should argumentNames and argumentRefKinds be adjusted as well? #Closed

I don't think so. We're getting argumentNames and argumentRefKinds from analyzedArguments (not from actualArguments or some other source).

AlekseyTs · 2025-12-10T19:33:32Z

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

+                ArrayBuilder<PropertySymbol>? properties = null;
+                foreach (var member in lookupResult.Symbols)
+                {
+                    if (member is PropertySymbol property)


member is PropertySymbol property

Should we check that it is an indexer? #Closed

AlekseyTs · 2025-12-10T19:43:15Z

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs


-            overloadResolutionResult.Free();
-            return propertyAccess;
+            bool isNewExtensionMember = property.IsExtensionBlockMember();


isNewExtensionMember

Consider avoiding using "newExtension" term. All features are new only until they are shipped. Consider using terms that "survive" long term #Closed

AlekseyTs · 2025-12-10T19:44:31Z

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs


-                // Make sure that the result of overload resolution is valid.
-                var gotError = MemberGroupFinalValidationAccessibilityChecks(receiver, property, syntax, diagnostics, invokedAsExtensionMethod: false);
+        private BoundExpression BindIndexerOrIndexedPropertyAccessContinued(SyntaxNode syntax, BoundExpression receiver, AnalyzedArguments analyzedArguments, BindingDiagnosticBag diagnostics, ImmutableArray<string> argumentNames, ImmutableArray<RefKind> argumentRefKinds, MemberResolutionResult<PropertySymbol> resolutionResult)


BoundExpression

BoundIndexerAccess? #Closed

AlekseyTs · 2025-12-10T19:45:11Z

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

+                Binder binder,
+                ExtensionScope scope,
+                BindingDiagnosticBag diagnostics,
+                out BoundExpression? extensionIndexerAccess)


BoundExpression

BoundIndexerAccess? #Closed

AlekseyTs · 2025-12-10T19:45:44Z

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

            }
        }

+        private bool TryBindExtensionIndexer(SyntaxNode syntax, BoundExpression left, AnalyzedArguments analyzedArguments, BindingDiagnosticBag diagnostics, [NotNullWhen(true)] out BoundExpression? extensionIndexerAccess)


BoundExpression

BoundIndexerAccess? #Closed

AlekseyTs · 2025-12-11T00:02:15Z

src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs

            singleLookupResults.Free();
        }

+        private void LookupAllNewExtensionMembersInSingleBinder(LookupResult result, string? name,


NewExtensionMembers

Similar comment for "NewExtensionMembers" term. It looks like this is applicable to other new APIs. #Closed

AlekseyTs · 2025-12-11T00:10:03Z

src/Compilers/CSharp/Portable/Binder/Binder_Lookup.cs

+                int arity, LookupOptions options, Binder originalBinder, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        {
+            var singleLookupResults = ArrayBuilder<SingleLookupResult>.GetInstance();
+            EnumerateAllNewExtensionMembersInSingleBinder(singleLookupResults, name, arity, options, originalBinder, ref useSiteInfo);


EnumerateAllNewExtensionMembersInSingleBinder

Consider asserting that result is null. Or conditionally Free it. #Closed

AlekseyTs · 2025-12-11T00:14:44Z

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

+                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = binder.GetNewCompoundUseSiteInfo(diagnostics);
+
+                scope.Binder.LookupAllNewExtensionMembersInSingleBinder(
+                    lookupResult, WellKnownMemberNames.Indexer, arity: 0, LookupOptions.AllMethodsOnArityZero,


LookupOptions.AllMethodsOnArityZero

Do we actually expect to get back any methods? #Closed

We could get a method back. The logic below filters them out.

But your question made me realize we were misusing the AllMethodsOnArityZero flag, so removed it here.
For methods and named types, explicit type arguments can be used, so we need the option of looking up with or without explicit arity. But for properties/indexers, we don't need such an option. Adjusted extensionMemberMatches in NamedTypeSymbol.GetExtensionMembers to always find properties/indexers from generic extension blocks given arity zero.

AlekseyTs · 2025-12-11T00:19:49Z

src/Compilers/CSharp/Portable/Binder/Binder_Statements.cs

                            return;
                        case BoundIndexerAccess { Indexer.SetMethod: { } indexerSet } indexer when indexerSet.IsExtensionBlockMember():
                            methodInvocationInfo = MethodInvocationInfo.FromIndexerAccess(indexer);
-                            Debug.Assert(ReferenceEquals(methodInvocationInfo.MethodInfo.Method, indexerSet));


Debug.Assert(ReferenceEquals(methodInvocationInfo.MethodInfo.Method, indexerSet));

What method do we get now? #Closed

We get an identical but not reference-equal method. SubstitutedPropertySymbol.GetMethod and .SetMethod return new symbols every time they are called.

Let's assert the equality fact then?

AlekseyTs · 2025-12-11T00:26:46Z

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_IndexerAccess.cs

                    // Tracked by https://github.com/dotnet/roslyn/issues/71056
                    AddPlaceholderReplacement(argumentPlaceholder, integerArgument);
-                    // https://github.com/dotnet/roslyn/issues/78829 - Do we need to do something special for recievers of extension indexers here?
+                    Debug.Assert(!indexerAccess.Indexer.IsExtensionBlockMember());


Debug.Assert(!indexerAccess.Indexer.IsExtensionBlockMember());

This looks suspicious. Are we saying that extension indexers will not participate in implicit indexing pattern? #Closed

I think the comment is useful until the design decision is pending. Consider transforming it into a PROTOTYPE comment, if you simply want to remove a link to the issue.

AlekseyTs · 2025-12-22T20:04:57Z

src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs

+                Debug.Assert(member.Kind != SymbolKind.NamedType);
+                if (member.Kind == SymbolKind.Method
+                    && (options & LookupOptions.AllMethodsOnArityZero) == 0
                    && arity != member.GetMemberArityIncludingExtension())


arity != member.GetMemberArityIncludingExtension()

Shouldn't non methods be filtered by this condition as well? #Closed

AlekseyTs · 2025-12-22T20:12:52Z

    CreateCompilation([src, libSrc], parseOptions: TestOptions.Regular14).VerifyEmitDiagnostics(

Are we covering RegularNext and Preview for this scenario? #Closed

Refers to: src/Compilers/CSharp/Test/CSharp15/ExtensionIndexersTests.cs:63 in 8dad62b. [](commit_id = 8dad62b, deletion_comment = False)

AlekseyTs · 2025-12-22T20:49:39Z

    var verifier = CompileAndVerify(comp, expectedOutput: ExpectedOutput("^1"), verify: Verification.Skipped).VerifyDiagnostics();

Why is verification skipped? #Resolved

Refers to: src/Compilers/CSharp/Test/CSharp15/ExtensionIndexersTests.cs:2598 in 8dad62b. [](commit_id = 8dad62b, deletion_comment = False)

AlekseyTs · 2025-12-22T20:53:41Z

    var verifier = CompileAndVerify(comp, expectedOutput: ExpectedOutput("False ^1 False"), verify: Verification.Skipped).VerifyDiagnostics();

Why is verification skipped? #Resolved

Refers to: src/Compilers/CSharp/Test/CSharp15/ExtensionIndexersTests.cs:2654 in 8dad62b. [](commit_id = 8dad62b, deletion_comment = False)

AlekseyTs · 2025-12-22T20:55:45Z

    var verifier = CompileAndVerify(comp, expectedOutput: ExpectedOutput("1..^0"), verify: Verification.Skipped).VerifyDiagnostics();

Why is verification skipped? #Resolved

Refers to: src/Compilers/CSharp/Test/CSharp15/ExtensionIndexersTests.cs:2763 in 8dad62b. [](commit_id = 8dad62b, deletion_comment = False)

AlekseyTs · 2025-12-22T21:05:47Z

src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs


        comp = CreateCompilation(src, targetFramework: TargetFramework.Net70);
-        comp.VerifyEmitDiagnostics();
+        CompileAndVerify(comp, expectedOutput: ExpectedOutput("^1"), verify: Verification.Skipped).VerifyDiagnostics();


Verification.Skipped

Why is verification skipped?

I skipped verification in tests that use .NET Core TFM and therefore cannot verify on Desktop.

Could we use FailsPEVerify instead?

AlekseyTs · 2025-12-22T21:16:29Z

src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests2.cs

+
+        var comp = CreateCompilation(source, targetFramework: TargetFramework.Net100);
+        comp.VerifyEmitDiagnostics(
+            // (5,21): error CS8352: Cannot use variable 'span' in this context because it may expose referenced variables outside of their declaration scope


// (5,21): error CS8352: Cannot use variable 'span' in this context because it may expose referenced variables outside of their declaration scope

Shouldn't we get the same error for an assignment through property? #Closed

We do. I think that was already tested elsewhere. It would be something like _ = s.P; with an already created instance of S (which determines its escape scope).
The object creation scenario however is different. The created instance has its escape scoped computed from the inputs, which includes initializers.

AlekseyTs · 2025-12-22T21:20:55Z

src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests2.cs

+
+        var comp = CreateCompilation(source, targetFramework: TargetFramework.Net100);
+        comp.VerifyEmitDiagnostics(
+            // (5,25): error CS8352: Cannot use variable 'span' in this context because it may expose referenced variables outside of their declaration scope


// (5,25): error CS8352: Cannot use variable 'span' in this context because it may expose referenced variables outside of their declaration scope

Shouldn't we get the same error for an assignment through property? #Closed

Answered elsewhere

AlekseyTs · 2025-12-22T21:21:42Z

src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests2.cs

+
+        var comp = CreateCompilation(source, targetFramework: TargetFramework.Net100);
+        comp.VerifyEmitDiagnostics(
+            // (5,21): error CS8352: Cannot use variable 'span' in this context because it may expose referenced variables outside of their declaration scope


// (5,21): error CS8352: Cannot use variable 'span' in this context because it may expose referenced variables outside of their declaration scope

Shouldn't we get the same error for an assignment through property? #Closed

Answered elsewhere

AlekseyTs · 2025-12-22T21:24:35Z

src/Compilers/CSharp/Test/Semantic/Semantics/RefEscapingTests.cs

 ";
            var comp = CreateCompilationWithMscorlibAndSpan(csharp, parseOptions: TestOptions.Regular.WithLanguageVersion(languageVersion), options: TestOptions.UnsafeDebugDll);
-            comp.VerifyDiagnostics(
-                // (11,15): warning CS9080: Use of variable 'x' in this context may expose referenced variables outside of their declaration scope


// (11,15): warning CS9080: Use of variable 'x' in this context may expose referenced variables outside of their declaration scope

Was the warning wrong? #Closed

Yes, the struct is readonly so all its members are readonly. A readonly accessor does not risk capturing and exposing the referenced variable.

AlekseyTs · 2025-12-22T21:25:11Z

src/Compilers/CSharp/Test/Semantic/Semantics/RefEscapingTests.cs

 ";
            var comp = CreateCompilationWithMscorlibAndSpan(csharp, parseOptions: TestOptions.Regular.WithLanguageVersion(languageVersion), options: TestOptions.UnsafeDebugDll);
-            comp.VerifyDiagnostics(
-                // (11,15): warning CS9080: Use of variable 'x' in this context may expose referenced variables outside of their declaration scope


// (11,15): warning CS9080: Use of variable 'x' in this context may expose referenced variables outside of their declaration scope

Was the warning wrong? #Closed

Yes, the property is readonly so the accessors are readonly

AlekseyTs · 2025-12-22T21:25:34Z

src/Compilers/CSharp/Test/Semantic/Semantics/RefEscapingTests.cs

 ";
            var comp = CreateCompilationWithMscorlibAndSpan(csharp, parseOptions: TestOptions.Regular.WithLanguageVersion(languageVersion), options: TestOptions.UnsafeDebugDll);
-            comp.VerifyDiagnostics(
-                // (11,15): warning CS9080: Use of variable 'x' in this context may expose referenced variables outside of their declaration scope


// (11,15): warning CS9080: Use of variable 'x' in this context may expose referenced variables outside of their declaration scope

Was the warning wrong? #Closed

Yes, the setter is readonly

AlekseyTs · 2025-12-22T21:28:38Z

Done with review pass (commit 7)

AlekseyTs · 2025-12-22T21:33:06Z

It looks like some of the ref safety analysis changes are desirable regardless of extension indexers work. I think it would be good to open issues for corresponding scenarios and link them to this PR. Also, we should consider if it is worth making those changes in main directly #Closed

jcouv · 2025-12-25T16:33:00Z

    var verifier = CompileAndVerify(comp, expectedOutput: ExpectedOutput("^1"), verify: Verification.Skipped).VerifyDiagnostics();

Answered elsewhere

In reply to: 3684111329

Refers to: src/Compilers/CSharp/Test/CSharp15/ExtensionIndexersTests.cs:2598 in 8dad62b. [](commit_id = 8dad62b, deletion_comment = False)

jcouv · 2025-12-25T16:33:13Z

    var verifier = CompileAndVerify(comp, expectedOutput: ExpectedOutput("False ^1 False"), verify: Verification.Skipped).VerifyDiagnostics();

Same

In reply to: 3684119503

Refers to: src/Compilers/CSharp/Test/CSharp15/ExtensionIndexersTests.cs:2654 in 8dad62b. [](commit_id = 8dad62b, deletion_comment = False)

jcouv · 2025-12-25T16:33:22Z

    var verifier = CompileAndVerify(comp, expectedOutput: ExpectedOutput("1..^0"), verify: Verification.Skipped).VerifyDiagnostics();

Same

In reply to: 3684123771

Refers to: src/Compilers/CSharp/Test/CSharp15/ExtensionIndexersTests.cs:2763 in 8dad62b. [](commit_id = 8dad62b, deletion_comment = False)

jcouv · 2025-12-25T16:43:18Z

Opened #81796
Given this was not reported by users, I'm fine to wait for the feature to get merged to main for the fix to flow.

In reply to: 3684255145

AlekseyTs

LGTM (commit 8), with suggestion to use Verification.FailsPEVerify instead of Verification.Skipped

jcouv · 2025-12-27T21:53:10Z

@dotnet/roslyn-compiler for second review. Someone comfortable with ref analysis would be great. Thanks

jjonescz · 2026-01-05T13:43:49Z

src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs

-                var accessorKind = property.RefKind == RefKind.None ? AccessorKind.Set : AccessorKind.Get;
-                var methodInfo = MethodInfo.Create(property, accessorKind);
+                bool isSet = property.RefKind == RefKind.None;
+                var accessorKind = isSet ? AccessorKind.Set : AccessorKind.Get;


This variable looks unused. #Resolved

jjonescz · 2026-01-05T13:46:16Z

src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs

-                => new MethodInvocationInfo
+            public static MethodInvocationInfo FromIndexerReadAccess(BoundIndexerAccess indexerAccess, BoundExpression? substitutedReceiver = null)
+            {
+                Debug.Assert(indexerAccess.AccessorKind != AccessorKind.Set);


What if we get AccessorKind.Both here? Then this doesn't seem to be "indexer read access." #Resolved

"Both" does include a read, so the name of the method seems okay. But I could rename to FromIndexerGetter to avoid any ambiguity...

jjonescz · 2026-01-05T14:00:38Z

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

            OverloadResolutionResult<PropertySymbol> overloadResolutionResult = OverloadResolutionResult<PropertySymbol>.GetInstance();
            // We don't consider when we're in default parameter values or attribute arguments so that we avoid cycles. This is an error scenario,
            // so we don't care if we accidentally miss a parameter being applicable.
-            bool allowRefOmittedArguments = !InParameterDefaultValue && !InAttributeArgument && receiver.IsExpressionOfComImportType();


Should the comment above this variable be removed too? #Resolved

jjonescz · 2026-01-05T14:22:19Z

src/Compilers/CSharp/Test/Semantic/Semantics/RefEscapingTests.cs

+                Diagnostic(ErrorCode.ERR_CallArgMixing, "local[stackSpan]").WithArguments("S3.this[System.Span<int>]", "span").WithLocation(48, 9),
+                // (48,15): error CS8352: Cannot use variable 'stackSpan' in this context because it may expose referenced variables outside of their declaration scope
+                //         local[stackSpan]++; // 4
+                Diagnostic(ErrorCode.ERR_EscapeVariable, "stackSpan").WithArguments("stackSpan").WithLocation(48, 15),


Why do we produce these duplicate diagnostics now? #Resolved

Both the getter and the setter produce a diagnostic

jcouv self-assigned this Dec 9, 2025

jcouv added Area-Compilers Feature - Extension Indexers labels Dec 9, 2025

jcouv changed the title ~~Extension indexers: resolve extension indexers~~ Extension indexers: allow and resolve extension indexers Dec 9, 2025

jcouv force-pushed the extension-indexers branch 3 times, most recently from 37bad6f to 344fa46 Compare December 9, 2025 22:59

Extension indexers: allow and resolve extension indexers

f504f6e

jcouv force-pushed the extension-indexers branch from 344fa46 to f504f6e Compare December 9, 2025 23:28

jcouv marked this pull request as ready for review December 10, 2025 02:19

jcouv requested a review from a team as a code owner December 10, 2025 02:19

AlekseyTs reviewed Dec 10, 2025

View reviewed changes

AlekseyTs reviewed Dec 11, 2025

View reviewed changes

AlekseyTs reviewed Dec 22, 2025

View reviewed changes

Address feedback

a9ac148

jcouv requested review from a team and AlekseyTs December 25, 2025 18:08

AlekseyTs approved these changes Dec 27, 2025

View reviewed changes

jjonescz reviewed Jan 5, 2026

View reviewed changes

Address feedback

8264869

jcouv requested a review from jjonescz January 5, 2026 19:40

jcouv mentioned this pull request Jan 5, 2026

Test plan for "extension indexers" feature #81505

Open

19 tasks

jjonescz approved these changes Jan 6, 2026

View reviewed changes

jcouv merged commit 9efc8da into dotnet:features/extensions Jan 6, 2026
25 checks passed

jcouv deleted the extension-indexers branch January 6, 2026 18:47

Extension indexers: allow and resolve extension indexers #81607

Extension indexers: allow and resolve extension indexers #81607

Conversation

jcouv commented Dec 9, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

AlekseyTs commented Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

jcouv commented Dec 10, 2025

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jcouv Dec 20, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 10, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 11, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 11, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 11, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Dec 11, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

jcouv commented Dec 9, 2025 •

edited

Loading

AlekseyTs commented Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

jcouv Dec 20, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 10, 2025 •

edited

Loading

AlekseyTs Dec 11, 2025 •

edited

Loading

AlekseyTs Dec 11, 2025 •

edited

Loading

AlekseyTs Dec 11, 2025 •

edited

Loading

AlekseyTs Dec 11, 2025 •

edited

Loading

AlekseyTs Dec 11, 2025 •

edited

Loading

AlekseyTs Dec 22, 2025 •

edited

Loading

AlekseyTs commented Dec 22, 2025 •

edited

Loading

AlekseyTs commented Dec 22, 2025 •

edited by jcouv

Loading

AlekseyTs commented Dec 22, 2025 •

edited by jcouv

Loading

AlekseyTs commented Dec 22, 2025 •

edited by jcouv

Loading

AlekseyTs Dec 22, 2025 •

edited

Loading

AlekseyTs Dec 22, 2025 •

edited

Loading

AlekseyTs Dec 22, 2025 •

edited

Loading

AlekseyTs Dec 22, 2025 •

edited

Loading