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)

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

Relates to test plan #81505

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

It looks like the speclet says nothing about consumption scenarios

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

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.

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.

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?

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?

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?

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?

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?

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 "neExtension" term. All features are new only until they are shipped. Consider using terms that "survive" long term

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?

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?

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?

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.

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.

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?

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?

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?

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-11T00:43:38Z

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

+                return true;
+            }
+
+            if (member is PropertySymbol property)


member is PropertySymbol property

Consider either asserting, or, even better, explicitly checking that this is an indexer.

AlekseyTs · 2025-12-11T00:48:58Z

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


+        internal static bool IsAllowedExtensionMember(Symbol member, LanguageVersion languageVersion)
+        {
+            if (IsAllowedExtensionMemberInCSharp14(member))


IsAllowedExtensionMemberInCSharp14

It looks like this is the only use site for this method. Consider merging two methods, or, in other words, modifying the original method instead of splitting it.

AlekseyTs · 2025-12-11T01:16:26Z

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

+                    yield return defaultMemberAttribute;
+                }
+
+                static SynthesizedAttributeData? synthesizeDefaultMemberAttributeIfNeeded(ImmutableArray<ExtensionMarkerType> extensionMarkerTypes)


This implementation is valid only under condition that all indexers use the same metadata name. I think that right now this is enforced only by the fact that we disallow usage of "IndexerName" attribute on extension indexers. But we haven't made the final design decision on that. If we start supporting the attribute, then we either must enforce (not assume) the same metadata name for all indexers in the group, or the indexer name must become another part of the grouping name. #Closed

I think that right now this is enforced only by the fact that we disallow usage of "IndexerName" attribute on extension indexers.

It looks like my recollection was wrong. We allow "simple" forms of the attribute. And it looks like the enforcement of the same metadata name for all indexers in a group is already in place. But it would be good to ensure that we have a targeted test for that enforcement.

AlekseyTs · 2025-12-11T01:30:42Z

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

+
+        comp = CreateCompilation(src, targetFramework: TargetFramework.Net70);
+        comp.VerifyEmitDiagnostics(
+            // (2,5): error CS0021: Cannot apply indexing with [] to an expression of type 'C'


// (2,5): error CS0021: Cannot apply indexing with [] to an expression of type 'C'

I assume a design decision about this behavior is still pending. Consider adding a PROTOTYPE comment

AlekseyTs · 2025-12-11T01:39:09Z

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

+            Diagnostic(ErrorCode.ERR_ExtensionDisallowsIndexerMember, "this").WithArguments("preview").WithLocation(12, 20));
+
+        comp = CreateCompilation(src, targetFramework: TargetFramework.Net70);
+        CompileAndVerify(comp, expectedOutput: ExpectedOutput("^1"), verify: Verification.Skipped).VerifyDiagnostics();


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

This looks strange. Based on the previous test, int-based extension indexer is not used by pattern matching, but Index-based is used. Consider leaving a PROTOTYPE comment.

AlekseyTs · 2025-12-11T01:39:50Z

    comp = CreateCompilation(src, targetFramework: TargetFramework.Net70);

Is there still a value in creating this compilation?

Refers to: src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs:27521 in f504f6e. [](commit_id = f504f6e, deletion_comment = False)

AlekseyTs · 2025-12-11T01:43:18Z

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

+            Diagnostic(ErrorCode.ERR_ExtensionDisallowsIndexerMember, "this").WithArguments("preview").WithLocation(12, 20));
+
+        comp = CreateCompilation(src, targetFramework: TargetFramework.Net70);
+        CompileAndVerify(comp, expectedOutput: ExpectedOutput("^1"), verify: Verification.Skipped).VerifyDiagnostics();


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

Consider also testing scenarios when receiver must be boxed, see #81173

AlekseyTs · 2025-12-11T02:05:04Z

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

+        comp.VerifyDiagnostics();
+
+        comp = CreateCompilation(src, options: TestOptions.DebugExe);
+        CompileAndVerify(comp, expectedOutput: @"12: (o, s) => get_Item(o, s)").VerifyDiagnostics();


CompileAndVerify(comp, expectedOutput: @"12: (o, s) => get_Item(o, s)").VerifyDiagnostics();

This doesn't look right. We decided that we don't support extension properties (see the following test), the same reason is applicable to extension indexers, I think.

AlekseyTs · 2025-12-11T02:16:51Z

    s = e.get_Item(x, 0);

Is this a typo? I assume we expect to get similar ref safety errors on this and the previous line

Refers to: src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs:45874 in f504f6e. [](commit_id = f504f6e, deletion_comment = False)

AlekseyTs · 2025-12-11T02:19:14Z

    s[1.0] = x;

I assume we should get the same ref safety error on this line as for the next line, but it looks like we don't get it.

Refers to: src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs:45876 in f504f6e. [](commit_id = f504f6e, deletion_comment = False)

AlekseyTs · 2025-12-11T02:26:23Z

        context.RegisterSyntaxNodeAction(handle, SyntaxKind.PropertyDeclaration);

Consider registering for IndexerDeclarationSyntax as well. Otherwise, we are not asserting events for indexers.

Refers to: src/Compilers/CSharp/Test/Emit3/Semantics/ExtensionTests.cs:51905 in f504f6e. [](commit_id = f504f6e, deletion_comment = False)

AlekseyTs · 2025-12-11T02:32:43Z

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

+        if (refKind == "ref readonly")
+        {
+            comp2.VerifyDiagnostics(
+                // (15,9): warning CS9193: Argument 0 should be a variable because it is passed to a 'ref readonly' parameter


// (15,9): warning CS9193: Argument 0 should be a variable because it is passed to a 'ref readonly' parameter

Do we report this warning for an extension property? #Closed

It looks like we do

AlekseyTs · 2025-12-11T02:44:40Z

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

+        }
+        else
+        {
+            comp2.VerifyDiagnostics();


comp2.VerifyDiagnostics();

I think we should assert IL for the two cases that do not report an error.

AlekseyTs · 2025-12-11T04:59:56Z

public void Declaration_06()

Dupe of the previous test?

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

AlekseyTs · 2025-12-11T05:03:43Z

public void Declaration_11()

Dupe of Declaration_01?

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

AlekseyTs · 2025-12-11T05:15:00Z

    // Color Color receiver

I do not think there is such a thing with an index expression. Not to mention the fact that indexers cannot be static.

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

AlekseyTs · 2025-12-11T05:17:23Z

class C { }

Consider also testing with a struct type (receiver must be boxed).

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

AlekseyTs · 2025-12-11T05:21:24Z

    // inaccessible

Consider actually adding a test with accessibility

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

AlekseyTs · 2025-12-11T05:46:12Z

        // (1,24): error CS0131: The left-hand side of an assignment must be a variable, property or indexer

Does this look like a bug?

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

AlekseyTs · 2025-12-11T05:50:25Z

public void ConditionalAssignment_01()

Consider covering nullable value type scenario

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

AlekseyTs · 2025-12-11T05:50:37Z

public void ConditionalAccess_01()

Consider covering nullable value type scenario

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

AlekseyTs · 2025-12-11T05:55:21Z

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

+        {
+            if (property.IsExtensionBlockMember())
+            {
+                MessageID.IDS_FeatureExtensionIndexers.CheckFeatureAvailability(diagnostics, syntax);


MessageID.IDS_FeatureExtensionIndexers.CheckFeatureAvailability(diagnostics, syntax);

Consider skipping the check if the indexer is declared in the same module. We already complained on the declaration

AlekseyTs · 2025-12-11T05:59:14Z

public void Metadata_01()

Consider also testing with IndexerName attribute #Closed

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

AlekseyTs · 2025-12-11T06:05:25Z

public void Metadata_02(bool useCompilationReference)

Consider also testing with IndexerName attribute #Closed

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

AlekseyTs · 2025-12-11T06:22:51Z

_ = d[0];

We should test scenario with 'dynamic' argument and non-dynamic receiver

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

AlekseyTs · 2025-12-11T06:26:24Z

    // Irregular/legacy behavior for indexer arguments

I do not see any irregularity for indexer arguments. Could you elaborate?

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

AlekseyTs · 2025-12-11T06:28:38Z

public void RefAnalysis_Indexing_01()

Were RefAnalysis tests cloned from some existing regular indexers tests?

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

AlekseyTs · 2025-12-11T06:32:50Z

Done with review pass (commit 1)

jcouv · 2025-12-11T18:00:55Z

It looks like the speclet says nothing about consumption scenarios

Here's the corresponding PR to update the spec: dotnet/csharplang#9869

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

Extension indexers: allow and resolve extension indexers #81607

Are you sure you want to change the base?

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

Uh oh!

jcouv commented Dec 10, 2025

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!

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!

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.

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!

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 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!

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 commented Dec 11, 2025

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

AlekseyTs commented Dec 11, 2025

Uh oh!

AlekseyTs commented Dec 11, 2025

Uh oh!

AlekseyTs commented Dec 11, 2025

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 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 commented Dec 11, 2025 •

edited

Loading

AlekseyTs commented Dec 11, 2025 •

edited

Loading