Support declaring and binding to methods with `params Span<T>` #59123

cston · 2022-01-27T23:53:49Z

Initial feature changes:

Allow method declarations with params Span<T> and params ReadOnlySpan<T>
Allow calls in expanded form to methods declared with params Span<T> or params ReadOnlySpan<T>
Report -langversion errors
Allocate associated array at each callsite, with no sharing of array instances across calls
Prefer binding to overload with params Span<T> or params ReadOnlySpan<T> over params T[] in overload resolution; treat params Span<T> and params ReadOnlySpan<T> equally

Test plan #57049

…o ReadOnlySpan<T>

AlekseyTs · 2022-02-03T15:20:02Z

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

+            // PROTOTYPE: Test use-site diagnostics.
+            var useSiteInfo = new CompoundUseSiteInfo<AssemblySymbol>(_diagnostics, _compilation.Assembly);
+            var conversion = _compilation.Conversions.ClassifyImplicitConversionFromType(spanType, paramArrayType, ref useSiteInfo);
+            conversion.MarkUnderlyingConversionsCheckedRecursive();


MarkUnderlyingConversionsCheckedRecursive

It would be good to add a comment regarding why we think that checks performed by Binder do not have to be performed for this conversion. #Closed

AlekseyTs · 2022-02-03T15:40:04Z

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

-            return CreateParamArrayArgument(syntax, paramArrayType, arrayArgs, _compilation, this);
+            if (paramArrayType.IsSZArray())
+            {
+                return CreateParamArrayArgument(syntax, paramArrayType, arrayArgs, _compilation, this);


CreateParamArrayArgument

There are several more call sites for this method. Should they be adjusted as well? Also, would it make sense to move the logic that deals with param array to initial binding as we have done for default values? #Closed

AlekseyTs · 2022-02-03T15:40:39Z

src/Compilers/Core/Portable/WellKnownMember.cs

        System_Span_T__get_Item,
        System_Span_T__get_Length,
+        System_Span_T__op_Implicit_SpanReadOnlySpan,


System_Span_T__op_Implicit_SpanReadOnlySpan

Is this still used? #Closed

Yes, as we discussed offline, we'll use the well-known member for conversion.

AlekseyTs · 2022-02-03T15:55:15Z

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

+                    var parameter = ((BoundParameter)expr).ParameterSymbol;
+                    // params Span<T> value cannot be returned since that would
+                    // prevent sharing repeated allocations at the call-site.
+                    if (parameter.IsParams && !parameter.Type.IsSZArray())


IsParams

If I remember correctly, it used to be that this property on its own wasn't sufficient for a parameter to be treated as a "real" params parameter. The type and position was important as well. Also, even if parameter is a "real" params, it doesn't mean that Span<T> was created by compiler, a user-created span could be passed. Another thing to consider is the fact, that removing params is not a binary breaking change, but it looks like it is going to disable the safety check. Perhaps, it would be better to move the safety check to the consumer, where we know exactly what is going on rather than doing this at the definition site? #Closed

Updated check for params and added a PROTOTYPE comment to move the error reporting to the caller.

AlekseyTs · 2022-02-03T16:22:00Z

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

        {
            Debug.Assert((object)final == final.ContainingSymbol.GetParameters().Last());
-            return final.IsParams && ((ParameterSymbol)final.OriginalDefinition).Type.IsSZArray();
+            return final.IsParams && final.Type.IsParamsType(Compilation);


final.Type

This doesn't look equivalent, the OriginalDefinition is dropped. #Closed

AlekseyTs · 2022-02-03T16:24:05Z

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

+            }
+            if (type is NamedTypeSymbol { Arity: 1 } namedType)
+            {
+                return namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0];


namedType

Consider adding an assert at least for type's name. #Closed

AlekseyTs · 2022-02-03T16:27:21Z

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

@@ -1638,9 +1638,9 @@ private TypeSymbol GetParameterType(ParameterSymbol parameter, MemberAnalysisRes
        {
            var type = parameter.Type;
            if (result.Kind == MemberResolutionKind.ApplicableInExpandedForm &&
-                parameter.IsParams && type.IsSZArray())
+                parameter.IsParams && type.IsParamsType(Compilation))


parameter.IsParams

It looks like we are missing the ordinal check. #Closed

AlekseyTs · 2022-02-03T16:34:42Z

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

+            }
+            if (type is NamedTypeSymbol { Arity: 1 } namedType)
+            {
+                var constructedFrom = namedType.ConstructedFrom;


ConstructedFrom

It feels like this should be OriginalDefinition #Closed

AlekseyTs · 2022-02-03T16:47:12Z

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

@@ -507,15 +506,23 @@ private static void CheckParameterModifiers(BaseParameterSyntax parameter, Bindi
                // error CS1100: Method '{0}' has a parameter modifier 'this' which is not on the first parameter
                diagnostics.Add(ErrorCode.ERR_BadThisParam, thisKeyword.GetLocation(), owner.Name);
            }
-            else if (parameter.IsParams && owner.IsOperator())
+            else if (parameter.IsParams)


else if (parameter.IsParams)

The refactoring doesn't look equivalent. It is disabling the following checks even if no errors reported. Consider moving this if to the end of the chain, or restructuring the code to perform the following checks unless an error is reported (perhaps ignoring the language version error). #Closed

I believe the following checks are not applicable for a params parameter if no errors are reported here, although that may not be the case in the future, so I've moved this block to the end.

AlekseyTs · 2022-02-03T16:53:55Z

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

+            // for 'stackalloc' in LocalRewriter.VisitStackAllocArrayCreationBase().)
+
+            // For now, simply allocate the array on the heap: new Span<T>(new T[length])
+            var intType = _compilation.GetSpecialType(SpecialType.System_Int32);


GetSpecialType

We should use helper that reports diagnostics #Closed

We should use helper that reports diagnostics

This is marked as resolved, but I do not see any changes around reporting diagnostics.

AlekseyTs · 2022-02-03T16:56:44Z

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

+
+            // For now, simply allocate the array on the heap: new Span<T>(new T[length])
+            var intType = _compilation.GetSpecialType(SpecialType.System_Int32);
+            var array = new BoundArrayCreation(


BoundArrayCreation

It looks like we could use CreateParamArrayArgument helper to create this array. #Closed

CreateParamArrayArgument() creates an array and initializes the values. Ideally, the Span<T> here will be created through a BCL helper method so initialization will likely be handled separately from allocation.

the Span here will be created through a BCL helper method so initialization will likely be handled separately from allocation.

When and if this happens, then we will adjust implementation accordingly. At the moment, however, I see no good reason adding all this complexity when we have a perfectly good reusable helper.

AlekseyTs · 2022-02-03T17:04:10Z

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

+            // ...
+            // temp[n - 1] = arrayArgs[n - 1];
+            // temp
+            for (int i = 0; i < arrayArgs.Length; i++)


for (int i = 0; i < arrayArgs.Length; i++)

I am not sure why go through all this trouble when we can initialize the allocated array directly and we already have a helper for that. #Closed

To allow for allocation to be handled by a runtime helper method.

AlekseyTs · 2022-02-03T17:07:07Z

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

+            {
+                assignment = _factory.AssignmentExpression(
+                    _factory.Call(temp, spanGetItem, MakeLiteral(syntax, ConstantValue.Create(i), intType, this)),
+                    _factory.Convert(elementType, arrayArgs[i]));


_factory.Convert

Shouldn't the type match? #Closed

AlekseyTs · 2022-02-03T17:12:02Z

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

+                sideEffects.Add(assignment);
+            }
+
+            var expr = MakeConversionNode(syntax, temp, conversion, temp.Type, @checked: false);


temp.Type

Shouldn't this be paramArrayType? #Closed

AlekseyTs · 2022-02-03T17:15:23Z

Done with review pass (commit 2), tests are not looked at.

AlekseyTs · 2022-03-07T23:14:53Z

@cston It looks like there are legitimate test failures.

AlekseyTs · 2022-03-07T23:39:01Z

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

+                    // prevent sharing repeated allocations at the call-site.
+                    if (parameter.IsParams &&
+                        parameter.Ordinal == parameter.ContainingSymbol.GetParameterCount() - 1 &&
+                        !parameter.Type.IsSZArray())


!parameter.Type.IsSZArray()

If we are complaining about a span type, then we probably should check for that rather than checking that the type is not an array. #Closed

I think in error situations the type could be neither and the error will be unexpected and confusing.

Added PROTOTYPE comment.

AlekseyTs · 2022-03-08T00:15:18Z

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

+                    PropertySymbol p => p.GetOwnOrInheritedGetMethod() ?? p.GetOwnOrInheritedSetMethod(),
+                    _ => throw ExceptionUtilities.UnexpectedValue(methodOrIndexer),
+                };
+                return CreateParamArrayArgument(syntax, parameterType, arrayArgs, compilation, method, BindingDiagnosticBag.Discarded);


BindingDiagnosticBag.Discarded

It is not clear why we are discarding diagnostics and dependencies. #Closed

AlekseyTs · 2022-03-08T00:26:12Z

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

+                    PropertySymbol p => p.GetOwnOrInheritedGetMethod() ?? p.GetOwnOrInheritedSetMethod(),
+                    _ => throw ExceptionUtilities.UnexpectedValue(methodOrIndexer),
+                };
+                return CreateParamArrayArgument(syntax, parameterType, arrayArgs, compilation, method, BindingDiagnosticBag.Discarded);


method

I am not sure what we are doing here, the value in this local doesn't look like a containing method. #Closed

AlekseyTs · 2022-03-08T00:36:10Z

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

+          Children(4):
+              ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Span<System.Int32>, IsImplicit) (Syntax: 'F(1, 2)')
+                Left:
+                  ILocalReferenceOperation:  (OperationKind.LocalReference, Type: System.Span<System.Int32>, IsImplicit) (Syntax: 'F(1, 2)')


ILocalReferenceOperation: (OperationKind.LocalReference, Type: System.Span<System.Int32>, IsImplicit) (Syntax: 'F(1, 2)')

What is this local? I do not see any locals in the body. IOperation tree shouldn't contain any locals synthesized by lowering. #Closed

AlekseyTs · 2022-03-08T00:38:04Z

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

+    null
+  Arguments(1):
+      IArgumentOperation (ArgumentKind.ParamArray, Matching Parameter: args) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'F(1, 2)')
+        IOperation:  (OperationKind.None, Type: System.Span<System.Int32>, IsImplicit) (Syntax: 'F(1, 2)')


OperationKind.None

OperationKind.None is unexpected. #Closed

AlekseyTs · 2022-03-08T00:53:52Z

Done with review pass (commit 6)

cston · 2022-03-16T15:10:04Z

/azp run

azure-pipelines · 2022-03-16T15:27:33Z

Azure Pipelines successfully started running 4 pipeline(s).

AlekseyTs · 2022-03-17T23:33:21Z

src/Compilers/Core/Portable/WellKnownMembers.cs

                 (byte)(MemberFlags.PropertyGet),                                                                                                               // Flags
                 (byte)WellKnownType.ExtSentinel, (byte)(WellKnownType.System_Span_T - WellKnownType.ExtSentinel),                                              // DeclaringTypeId
                 0,                                                                                                                                             // Arity
                    0,                                                                                                                                          // Method Signature
                    (byte)SignatureTypeCode.TypeHandle, (byte)SpecialType.System_Int32, // Return Type

-                 // System_ReadOnlySpan__ctor
+                 // System_Span_T__op_Implicit_SpanReadOnlySpan
+                 (byte)(MemberFlags.Method | MemberFlags.Static),                                                                                    // Flags


MemberFlags.Method

Consider adding a PROTOTYPE comment to add dedicated flags for operators/conversions #Closed

AlekseyTs · 2022-03-17T23:44:11Z

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

+
+            static BoundExpression createBadExpression(SyntaxNode syntax, TypeSymbol type)
+            {
+                return new BoundBadExpression(syntax, LookupResultKind.NotReferencable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, type)


ImmutableArray.Empty

arrayArgs? Even in a missing helper scenarios we want IOperation tree to include values from source. #Closed

A PROTOTYPE comment will be fine for now, I think.

AlekseyTs

LGTM (commit 7), modulo a couple of suggested PROTOTYPE comments

AlekseyTs

LGTM (commit 8), assuming CI is passing

jcouv · 2022-03-23T23:48:07Z

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

+                        // than on the definition. That would allow calling this method with an explicit Span<T>
+                        // without an error. That's also important because changing the method defintion between
+                        // params and non-params is not a binary breaking change.
+                        Error(diagnostics, ErrorCode.ERR_EscapeParamsSpan, node, expr.Syntax);


Added a note to test plan. Per offline conversation, we need to figure out safe escape rules first.
Would it be okay to remove this error in the meantime? #Closed

jcouv · 2022-03-24T05:01:46Z

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

+            var m1Original = m1.LeastOverriddenMember.OriginalDefinition.GetParameters();
+            var m2Original = m2.LeastOverriddenMember.OriginalDefinition.GetParameters();
+
+            // Prefer params Span<T> or ReadOnlySpan<T> over params T[].


The spec says there's an order of preference: ReadOnlySpan<T> first, then Span<T>, T[] and IEnumerable<T> #Closed

jcouv · 2022-03-24T05:04:23Z

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

+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests


nit: consider file-scoped namespace while you can ;-) #ByDesign

jcouv · 2022-03-24T05:07:49Z

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

+                compilation,
+                diagnostics);
+
+            var spanConstructor = (MethodSymbol)Binder.GetWellKnownTypeMember(compilation, WellKnownMember.System_Span_T__ctorArray, diagnostics, syntax.Location);


nit: consider adding nullability annotation to GetWellKnownTypeMember and enabling around the new code #Closed

This file is nullable enabled, but I've left GetWellKnownTypeMember() as is, since that's probably beyond the scope of this PR.

jcouv · 2022-03-24T05:15:04Z

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

+                //         A.F2("span", 3);
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, @"A.F2(""span"", 3)").WithArguments("params Span<T>").WithLocation(8, 9));
+
+            compB = CreateCompilation(sourceB, references: new[] { refA }, targetFramework: TargetFramework.NetCoreApp, options: TestOptions.ReleaseExe);


Should use RegularNext (instead of preview) in tests that use Regular10 or CSharp10 #Resolved

jcouv · 2022-03-24T05:22:10Z

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

+
+            if (paramArrayType.IsReadOnlySpanType(compilation))
+            {
+                var spanToReadOnlySpanOperator = (MethodSymbol)Binder.GetWellKnownTypeMember(compilation, WellKnownMember.System_Span_T__op_Implicit_SpanReadOnlySpan, diagnostics, syntax.Location);


Consider adding test with missing newly-added well-known members System_Span_T__op_Implicit_SpanReadOnlySpan and System_Span_T__ctorArray
Never mind, found it: MissingSpanConstructor #Closed

jcouv

Done with review pass (iteration 8)

jcouv

LGTM Thanks (iteration 10)

cston · 2022-05-24T17:09:11Z

Tests pass locally but the feature branch is not up to date for CI.

jaredpar · 2022-05-24T17:14:27Z

@cston confirmed all the tests are passing locally. The CI machines changed out from under us durin the lifetime of this PR. The next merge from main should fix. Force merging now (it's a feature branch) and next merge from main should show green else we'll dig into the failures

dotnet-issue-labeler bot added the Area-Compilers label Jan 27, 2022

Support declaring and binding to methods with params Span<T>

81924db

cston force-pushed the params-span branch from aa2eae4 to 81924db Compare January 28, 2022 00:14

cston marked this pull request as ready for review January 28, 2022 00:53

cston requested a review from a team as a code owner January 28, 2022 00:53

Use ConversionsBase.ClassifyImplicitConversionFromType() to convert t…

3d190d5

…o ReadOnlySpan<T>

AlekseyTs reviewed Feb 3, 2022

View reviewed changes

cston added 4 commits February 22, 2022 11:27

Restore use of well-known conversion operator

bf3a9e6

PR feedback

988a54f

Fix tests

539acf1

PR feedback

16d96f2

AlekseyTs reviewed Mar 7, 2022

View reviewed changes

AlekseyTs reviewed Mar 8, 2022

View reviewed changes

PR feedback

57184b7

This was referenced Mar 16, 2022

Failure in CSharpCodeActions.GFUFuzzyMatchAfterRenameTrackingAndAfterGenerateType #57423

Closed

FixAllOccurrencesIgnoresGeneratedCode is flaky #56625

Open

cston requested a review from a team March 17, 2022 17:42

AlekseyTs reviewed Mar 17, 2022

View reviewed changes

AlekseyTs approved these changes Mar 17, 2022

View reviewed changes

PR feedback

e480445

AlekseyTs approved these changes Mar 18, 2022

View reviewed changes

jcouv reviewed Mar 23, 2022

View reviewed changes

jcouv reviewed Mar 24, 2022

View reviewed changes

jcouv marked this pull request as draft May 6, 2022 17:17

cston added 2 commits May 23, 2022 14:32

PR feedback

5d3f85f

Removed ErrorCode.ERR_EscapeParamsSpan

e68dd10

cston marked this pull request as ready for review May 23, 2022 21:44

runfoapp bot mentioned this pull request May 23, 2022

CI build fails due to Azure package feed error 503 (Service Unavailable) #57565

Closed

jcouv approved these changes May 23, 2022

View reviewed changes

jaredpar merged commit 92e9909 into dotnet:features/params-span May 24, 2022

Support declaring and binding to methods with params Span<T> #59123

Support declaring and binding to methods with params Span<T> #59123

Conversation

cston commented Jan 27, 2022 • edited by jcouv Loading

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Feb 3, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs commented Feb 3, 2022

AlekseyTs commented Mar 7, 2022

AlekseyTs Mar 7, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Mar 8, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Mar 8, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Mar 8, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Mar 8, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs commented Mar 8, 2022

cston commented Mar 16, 2022

azure-pipelines bot commented Mar 16, 2022

AlekseyTs Mar 17, 2022 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Mar 17, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs left a comment

Choose a reason for hiding this comment

AlekseyTs left a comment

Choose a reason for hiding this comment

jcouv Mar 23, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jcouv Mar 24, 2022 • edited Loading

Choose a reason for hiding this comment

jcouv Mar 24, 2022 • edited by cston Loading

Choose a reason for hiding this comment

jcouv Mar 24, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jcouv Mar 24, 2022 • edited by cston Loading

Choose a reason for hiding this comment

jcouv Mar 24, 2022 • edited Loading

Choose a reason for hiding this comment

Support declaring and binding to methods with `params Span<T>` #59123

Support declaring and binding to methods with `params Span<T>` #59123

cston commented Jan 27, 2022 •

edited by jcouv

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Feb 3, 2022 •

edited

Loading

AlekseyTs Mar 7, 2022 •

edited

Loading

AlekseyTs Mar 8, 2022 •

edited

Loading

AlekseyTs Mar 8, 2022 •

edited

Loading

AlekseyTs Mar 8, 2022 •

edited

Loading

AlekseyTs Mar 8, 2022 •

edited

Loading

AlekseyTs Mar 17, 2022 •

edited

Loading

AlekseyTs Mar 17, 2022 •

edited

Loading

jcouv Mar 23, 2022 •

edited

Loading

jcouv Mar 24, 2022 •

edited

Loading

jcouv Mar 24, 2022 •

edited by cston

Loading

jcouv Mar 24, 2022 •

edited

Loading

jcouv Mar 24, 2022 •

edited by cston

Loading

jcouv Mar 24, 2022 •

edited

Loading