Extension indexers: indexing with implicit indexers by jcouv · Pull Request #82453 · dotnet/roslyn

jcouv · 2026-02-19T06:22:42Z

The implicit indexers in list-patterns will be addressed in a follow-up.

I'm still working on updating the spec. In short, for each scope (ie. instance, then iterative extension scopes), we look for real indexer and fall back to implicit indexer.
This means that both parts of an implicit indexer must be present in the same scope to count.

Relates to test plan #81505

dotnet-policy-service · 2026-02-19T19:14:03Z

This PR modifies public API files. Please follow the instructions at https://github.com/dotnet/roslyn/blob/main/docs/contributing/API%20Review%20Process.md for ensuring all public APIs are reviewed before merging.

jjonescz · 2026-02-20T09:48:21Z

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

+            if (arguments.Arguments.Count != 1)
+            {
+                return IndexOrRangeArgKind.None;
+            }
+
+            TypeSymbol? argType = arguments.Arguments[0].Type;
+            if (argType is null)


nit: could be simplified to

Suggested change

if (arguments.Arguments.Count != 1)

{

return IndexOrRangeArgKind.None;

}

TypeSymbol? argType = arguments.Arguments[0].Type;

if (argType is null)

if (arguments.Arguments is not [{ Type: TypeSymbol argType }])

{

return IndexOrRangeArgKind.None;

}

``` #Pending

jjonescz · 2026-02-20T10:10:45Z

src/Compilers/CSharp/Test/CSharp15/ExtensionIndexersTests.cs

@@ -702,6 +701,41 @@ public int this[int i]

    [Fact]
    public void Indexing_09()


Renumbering lots of tests seems unfortunate; next time consider some suffix like Indexing_09_02 to "insert" a new test.

AlekseyTs · 2026-02-20T16:53:10Z

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

+                return IndexOrRangeArgKind.None;
+            }
+
+            if (TypeSymbol.Equals(argType, Compilation.GetWellKnownType(WellKnownType.System_Index), TypeCompareKind.ConsiderEverything))


TypeCompareKind.ConsiderEverything

It looks like we are all over the place when it comes to TypeCompareKind used when we are matching Index type. Consider extracting a helper and unifying all usages on TypeCompareKind.AllIgnoreOptions. #Pending

AlekseyTs · 2026-02-20T16:53:37Z

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

+                return IndexOrRangeArgKind.Index;
+            }
+
+            if (TypeSymbol.Equals(argType, Compilation.GetWellKnownType(WellKnownType.System_Range), TypeCompareKind.ConsiderEverything))


TypeCompareKind.ConsiderEverything

Similar suggestion #Pending

AlekseyTs · 2026-02-20T17:01:36Z

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


-            lookupResult.Free();
-            actualArguments?.Free();
+                    if (argKind != IndexOrRangeArgKind.None


argKind != IndexOrRangeArgKind.None

Consider checking receiverPlaceholder for not null instead. Then we wouldn't need a suppression below. #Pending

AlekseyTs · 2026-02-20T17:15:53Z

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

+                        LookupResultKind.Viable, hasErrors: false).MakeCompilerGenerated();
+
+                    lengthOrCountAccess = binder.CheckValue(lengthOrCountAccess, BindValueKind.RValue, diagnostics);
+


Would it be possible to extract a common helper to share with TryBindLengthOrCount?

Reusing GetExtensionMemberAccess or its relevant portion would be fine too.

AlekseyTs · 2026-02-20T17:32:08Z

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

+
+                candidates.Free();
+                diagnostics.Add(syntax, useSiteInfo);
+                return lengthOrCountProperty is not null;


lengthOrCountProperty

It looks like we are grabbing the first found property and ignoring any ambiguity across same name properties. Also, it looks like we are not checking applicability to the receiver type. It feels like we need to collect a group. run an overload resolution process to get a best match, then create a BoundPropertyAccess (hopefully reusing GetExtensionMemberAccess or its relevant portion). #Pending

BTW, a true ambiguity should probably prevent us from going to the next scope.

I hope we will be able to share/reuse code that deals with binding extension properties explicitly used in code.

You're right. I missed the generic cases. Noticed the problem while working on next PR. Unlike instance scenario, we need to do overload resolution, that will give us type inference and deal with ambiguities

AlekseyTs · 2026-02-20T17:40:04Z

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

+                    candidates, WellKnownMemberNames.Indexer, alternativeName: null,
+                    arity, lookupOptions, originalBinder: binder);
+
+                var intPlaceholder = new BoundImplicitIndexerValuePlaceholder(syntax, binder.Compilation.GetSpecialType(SpecialType.System_Int32)) { WasCompilerGenerated = true };


binder.Compilation.GetSpecialType(SpecialType.System_Int32)

Why is it safe to ignore any use-site errors here?

AlekseyTs · 2026-02-20T18:01:58Z

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

+                        analyzedArguments.Free();
+                        candidates.Free();
+                        diagnostics.Add(syntax, useSiteInfo);
+                        return indexerOrSliceAccess is not null;


indexerOrSliceAccess

It looks like we have the same issue with ambiguity handling here too.

AlekseyTs · 2026-02-20T18:06:31Z

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

+                        var properties = ArrayBuilder<PropertySymbol>.GetInstance();
                        properties.Add(property);
+
+                        OverloadResolutionResult<PropertySymbol> overloadResolutionResult = resolveIndexers(receiver, properties, binder, analyzedArguments, ref actualArguments, ref useSiteInfo);


OverloadResolutionResult overloadResolutionResult = resolveIndexers(receiver, properties, binder, analyzedArguments, ref actualArguments, ref useSiteInfo);

It feels like we should be able to share/reuse tryBindExtensionIndexersInScope or at least significant portion of it, rather than duplicating the logic here and below. #Pending

AlekseyTs · 2026-02-20T18:14:09Z

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

+
+                        candidates.Free();
+                        diagnostics.Add(syntax, useSiteInfo);
+                        return true;


return true;

It looks like we have the same issue with ambiguity handling here too.

AlekseyTs · 2026-02-20T18:25:46Z

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

            {
-                if (TryBindExtensionIndexer(syntax, receiver, analyzedArguments, diagnostics, out BoundIndexerAccess extensionIndexerAccess))
+                if (TryBindNonExtensionImplicitIndexer(syntax, receiver, analyzedArguments, diagnostics, out var fallbackIndexerAccess)
+                    || TryBindExtensionIndexer(syntax, receiver, analyzedArguments, diagnostics, out fallbackIndexerAccess))


|| TryBindExtensionIndexer(syntax, receiver, analyzedArguments, diagnostics, out fallbackIndexerAccess)

This doesn't feel right. It looks like the enclosing method is called from BindNonExtensionIndexerOrIndexedPropertyAccess. Therefore, I would not expect it to touch extensions at all.

AlekseyTs · 2026-02-20T18:37:01Z

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

-            }
        }

        internal static bool MethodHasValidSliceSignature(MethodSymbol method)


MethodHasValidSliceSignature

Please move this method to its original place so that the diff is clear. #Pending

AlekseyTs · 2026-02-20T18:42:40Z

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

+        /// Checks whether a property has a valid getter for the Length/Count implicit indexer pattern
+        /// (non-static, returns int, non-ref).
+        /// </summary>
+        private static bool IsValidLengthOrCountGetter(PropertySymbol property)


IsValidLengthOrCountGetter

HasValidLengthOrCountGetter? #Pending

AlekseyTs · 2026-02-20T18:45:06Z

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

+        /// Checks whether a property is a valid implicit Index indexer
+        /// (single int parameter, non-ref, non-static).
+        /// </summary>
+        private static bool IsValidImplicitIndexIndexer(PropertySymbol property)


IsValidImplicitIndexIndexer

Unlike the previous helper, this one doesn't check if there is a getter. Should it? #Pending

AlekseyTs · 2026-02-20T18:47:07Z

Done with review pass (commit 1)

jcouv self-assigned this Feb 19, 2026

jcouv added Area-Compilers Feature - Extension Indexers labels Feb 19, 2026

jcouv force-pushed the indexers_08 branch 2 times, most recently from 9388e37 to 19e7436 Compare February 19, 2026 18:29

jcouv changed the base branch from main to features/extensions February 19, 2026 18:46

jcouv force-pushed the indexers_08 branch from 19e7436 to 842a54c Compare February 19, 2026 19:13

dotnet-policy-service bot added VSCode Needs API Review Needs to be reviewed by the API review council labels Feb 19, 2026

Extension indexers: indexing with implicit indexers

5a85a82

jcouv force-pushed the indexers_08 branch from 842a54c to 5a85a82 Compare February 19, 2026 22:12

jcouv marked this pull request as ready for review February 20, 2026 00:57

jcouv requested a review from a team as a code owner February 20, 2026 00:57

jcouv removed Needs API Review Needs to be reviewed by the API review council VSCode labels Feb 20, 2026

jjonescz approved these changes Feb 20, 2026

View reviewed changes

AlekseyTs reviewed Feb 20, 2026

View reviewed changes

		@@ -702,6 +701,41 @@ public int this[int i]

		[Fact]
		public void Indexing_09()

		LookupResultKind.Viable, hasErrors: false).MakeCompilerGenerated();

		lengthOrCountAccess = binder.CheckValue(lengthOrCountAccess, BindValueKind.RValue, diagnostics);

Comments

Conversation

jcouv commented Feb 19, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

dotnet-policy-service bot commented Feb 19, 2026

Uh oh!

jjonescz Feb 20, 2026 • edited by jcouv 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 Feb 20, 2026 • edited by jcouv 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 Feb 20, 2026 • edited by jcouv 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 Feb 20, 2026 • edited by jcouv 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!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Feb 20, 2026 • edited by jcouv 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!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Feb 20, 2026 • 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 Feb 20, 2026 • edited by jcouv 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!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs Feb 20, 2026 • edited by jcouv 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 Feb 20, 2026 • edited by jcouv 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 Feb 20, 2026 • edited by jcouv 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 commented Feb 20, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

3 participants

jcouv commented Feb 19, 2026 •

edited

Loading

jjonescz Feb 20, 2026 •

edited by jcouv

Loading

AlekseyTs Feb 20, 2026 •

edited by jcouv

Loading

AlekseyTs Feb 20, 2026 •

edited by jcouv

Loading

AlekseyTs Feb 20, 2026 •

edited by jcouv

Loading

AlekseyTs Feb 20, 2026 •

edited by jcouv

Loading

AlekseyTs Feb 20, 2026 •

edited

Loading

AlekseyTs Feb 20, 2026 •

edited by jcouv

Loading

AlekseyTs Feb 20, 2026 •

edited by jcouv

Loading

AlekseyTs Feb 20, 2026 •

edited by jcouv

Loading

AlekseyTs Feb 20, 2026 •

edited by jcouv

Loading