Test plan followup #44257

333fred · 2020-05-14T17:13:01Z

Added support for the remaining compiler-side required test plan work. @AlekseyTs @dotnet/roslyn-compiler for review. I recommend reviewing this PR commit-by-commit for ease of review.

Relates to #43321

…ers.

333fred · 2020-05-15T16:29:48Z

@AlekseyTs @dotnet/roslyn-compiler for review.

AlekseyTs · 2020-05-15T23:03:10Z

src/Compilers/Core/Portable/Compilation/Compilation.cs

                        default:
-                            return s.ContainingAssembly;
+                            return assemblyIsInReferences(s.ContainingAssembly);


return assemblyIsInReferences(s.ContainingAssembly); [](start = 28, length = 52)

It looks like for a NamedType which isn't a definition we should check all type arguments, including from containing types. Could be a breaking change though. #Closed

Filed #44345 to follow up on this.

In reply to: 426081997 [](ancestors = 426081997)

AlekseyTs · 2020-05-15T23:06:18Z

src/Compilers/Core/Portable/Compilation/Compilation.cs

+                            var funcPtr = (IFunctionPointerTypeSymbol)s;
+                            if (!isContainingAssemblyInReferences(funcPtr.Signature.ReturnType))
+                            {
+                                return false;


false [](start = 39, length = 5)

Is this code path covered by tests? #Closed

Added a new test to AccessCheckTests for these.

In reply to: 426082638 [](ancestors = 426082638)

AlekseyTs · 2020-05-15T23:06:27Z

src/Compilers/Core/Portable/Compilation/Compilation.cs

+                            {
+                                if (!isContainingAssemblyInReferences(param.Type))
+                                {
+                                    return false;


return false; [](start = 36, length = 13)

Is this code path covered by tests? #Closed

AlekseyTs · 2020-05-15T23:20:26Z

src/Compilers/Core/Portable/Symbols/TypeCompareKind.cs

@@ -25,6 +25,7 @@ internal enum TypeCompareKind
        IgnoreNullableModifiersForReferenceTypes = 8,
        ObliviousNullableModifierMatchesAny = 16,
        IgnoreNativeIntegers = 32,
+        FunctionPointerRefMatchesOutInRefReadonly = 64,


FunctionPointerRefMatchesOutInRefReadonly [](start = 8, length = 41)

Consider adding a doc comment, including a brief explanation when is this needed. #Closed

Also, it feels strange to have an "ignore" option that is not part of AllIgnoreOptions. Might want to explain this as well.

In reply to: 426085624 [](ancestors = 426085624)

AlekseyTs · 2020-05-15T23:29:57Z

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

@@ -313,6 +313,10 @@ internal class MemberSignatureComparer : IEqualityComparer<Symbol>
            _considerCallingConvention = considerCallingConvention;
            _considerRefKindDifferences = considerRefKindDifferences;
            _typeComparison = typeComparison;
+            if (!considerRefKindDifferences)
+            {
+                _typeComparison |= TypeCompareKind.FunctionPointerRefMatchesOutInRefReadonly;


TypeCompareKind.FunctionPointerRefMatchesOutInRefReadonly [](start = 35, length = 57)

Can we assert that this option is never set on entry? #Closed

We could, but I'm not sure what invariant that would be trying to preserve? Could you elaborate on what type of bug you think that would catch?

In reply to: 426087571 [](ancestors = 426087571)

We could, but I'm not sure what invariant that would be trying to preserve? Could you elaborate on what type of bug you think that would catch?

From reviewing the change, I assumed that TypeCompareKind.FunctionPointerRefMatchesOutInRefReadonly is a very special flag. It is meant to be used by this component and it is really not appropriate (suspicious) to use it anywhere else in the code base. If the assumption is correct, the assert would explicitly indicate the intent and could possibly prevent people from misusing the flag.

In reply to: 426889306 [](ancestors = 426889306,426087571)

AlekseyTs · 2020-05-15T23:33:43Z

        => Hash.Combine(ReturnType, Hash.Combine(CallingConvention.GetHashCode(), RefKind.GetHashCode()));

It feels like this should be relaxed, since we are relaxing RefKind comparison. #Closed

Refers to: src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs:400 in 447d87f. [](commit_id = 447d87f, deletion_comment = False)

AlekseyTs · 2020-05-15T23:34:52Z

        => Hash.Combine(TypeWithAnnotations.GetHashCode(), RefKind.GetHashCode());

It feels like this should be relaxed, since we are relaxing RefKind comparison. #Closed

Refers to: src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerParameterSymbol.cs:63 in 447d87f. [](commit_id = 447d87f, deletion_comment = False)

AlekseyTs · 2020-05-15T23:38:32Z

src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerTypeSymbol.cs

+        {
+            if ((compareKind & TypeCompareKind.FunctionPointerRefMatchesOutInRefReadonly) != 0)
+            {
+                return (refKind1, refKind2) switch


(refKind1, refKind2) switch [](start = 23, length = 27)

Why so complicated? It looks like MemberSignatureComparer simply does (refKind1 == RefKind.None) == (refKind2 == RefKind.None) #Closed

I found this significantly more readable than the version in MemberSignatureComparer.

In reply to: 426089324 [](ancestors = 426089324)

I found this significantly more readable than the version in MemberSignatureComparer.

I spent significant amount of time trying to figure out your intent here (time I could have spent elsewhere) and whether all the right combinations are handled and handled properly. Every reader will have to go through the same trouble over and over again. I understand your desire to use switch expressions everywhere you can, but in this case, I believe it makes code less clear and unnecessarily complicated. Please use simplified form of the check, especially that we are already using it elsewhere.

In reply to: 426821892 [](ancestors = 426821892,426089324)

I understand your desire to use switch expressions everywhere you can

To be clear, that is not the motivation.

I spent significant amount of time trying to figure out your intent here (time I could have spent elsewhere) and whether all the right combinations are handled and handled properly.

And I spent probably a similar amount of time creating a truth table in my head for the original check to be sure that I could understand what it was checking. I used this form because I genuinely find it significantly easier to read. I don't find the other form simpler in any fashion.

In reply to: 426825848 [](ancestors = 426825848,426821892,426089324)

I'll change this. However, I want to be clear that I don't just use new features for the fun of it. I use them when it would help me to read the code better, and I find that writing out the truth table (as I can do concisely here with a switch expression) is significantly easier to understand. I'll change this because we have prior art in the form of a comparison, but in future code that does similar things I'm still going to prefer using the form I understand more easily.

In reply to: 426840351 [](ancestors = 426840351,426825848,426821892,426089324)

AlekseyTs · 2020-05-15T23:41:52Z

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

@@ -102,7 +102,8 @@ internal static TypeSymbol CopyTypeCustomModifiers(TypeSymbol sourceType, TypeSy

            Debug.Assert(resultType.Equals(sourceType, TypeCompareKind.IgnoreDynamicAndTupleNames | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes)); // Same custom modifiers as source type.

-            Debug.Assert(resultType.Equals(destinationType, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds)); // Same object/dynamic, nullability and tuple names as destination type.
+            // Same object/dynamic, nullability and tuple names as destination type.
+            Debug.Assert(resultType.Equals(destinationType, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNativeIntegers));


| TypeCompareKind.IgnoreNativeIntegers [](start = 124, length = 39)

This doesn't feel right. Native int types specified in source should be preserved. #Closed

@cston can you comment? Regardless I don't want to make a change around native int encoding in this PR, so I'm either going to skip the tests that hit this assert or keep this as is.

In reply to: 426089925 [](ancestors = 426089925)

It sounds like a bug. Please log an issue, thanks.

In reply to: 426823520 [](ancestors = 426823520,426089925)

Filed #44358.

In reply to: 426836636 [](ancestors = 426836636,426823520,426089925)

Removed the flag and skipped the relevant test.

In reply to: 426894790 [](ancestors = 426894790,426836636,426823520,426089925)

AlekseyTs · 2020-05-15T23:54:44Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs

+}}
+unsafe class Derived : Base
+{{
+    protected override void M1(delegate*<{type2}> ptr) {{}}


M1 [](start = 28, length = 2)

Consider asserting what signature do we end up with at the end. #Closed

AlekseyTs · 2020-05-15T23:54:56Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs

+}
+unsafe class Derived : Base
+{
+    protected override void M1(delegate*<(int i, string s)> ptr) {{}}


M1 [](start = 28, length = 2)

Consider asserting what signature do we end up with at the end. #Closed

AlekseyTs · 2020-05-15T23:55:31Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs

+}
+unsafe class Derived : Base
+{
+    protected override void M1(delegate*<string> ptr) {{}}


M1 [](start = 28, length = 2)

Consider asserting what signature do we end up with at the end. #Closed

AlekseyTs · 2020-05-15T23:55:57Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs

+}
+unsafe class Derived : Base
+{
+    protected override void M1(delegate*<ref string> ptr) {{}}


M1 [](start = 28, length = 2)

Consider asserting what signature do we end up with at the end. #Closed

AlekseyTs · 2020-05-15T23:56:40Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs

+}
+unsafe class Derived : Base
+{
+    protected override void M1(ref delegate*<string> ptr) {{}}


M1 [](start = 28, length = 2)

Consider asserting what signature do we end up with at the end. #Closed

AlekseyTs · 2020-05-16T00:02:29Z

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

            comp.VerifyDiagnostics(
                // (12,13): error CS0173: Type of conditional expression cannot be determined because there is no implicit conversion between 'delegate*<string>' and 'delegate*<string>'
                //         _ = b ? ptr1 : ptr3;
                Diagnostic(ErrorCode.ERR_InvalidQM, "b ? ptr1 : ptr3").WithArguments("delegate*<string>", "delegate*<string>").WithLocation(12, 13),
                // (13,13): error CS0173: Type of conditional expression cannot be determined because there is no implicit conversion between 'delegate*<string>' and 'delegate*<string?>'
                //         _ = b ? ptr1 : ptr4;
                Diagnostic(ErrorCode.ERR_InvalidQM, "b ? ptr1 : ptr4").WithArguments("delegate*<string>", "delegate*<string?>").WithLocation(13, 13),
+                // (14,24): warning CS8619: Nullability of reference types in value of type 'delegate*<string?>' doesn't match target type 'delegate*<string>'.


delegate* [](start = 140, length = 17)

Shouldn't we infer delegate*<string?> instead? #Closed

No, these are refs. Unfortunately, our CSharpErrorMessageFormat does not include return ref kinds, so the error message isn't super clear. I could change that to include them, but I'm unsure of the fully ramifications of such a change.

In reply to: 426093508 [](ancestors = 426093508)

Unfortunately, our CSharpErrorMessageFormat does not include return ref kinds, so the error message isn't super clear.

Since this isn't really a member, perhaps the symbol display for function pointers shouldn't be driven by the options for members and should always display ref kind because this is important aspect of the type. Same for other things we might be dropping

In reply to: 426844096 [](ancestors = 426844096,426093508)

I've added a note to the tracking issue to consider that change, will resolve this thread.

In reply to: 426910541 [](ancestors = 426910541,426844096,426093508)

AlekseyTs · 2020-05-16T00:14:45Z

    public static bool HaveSameReturnTypes(MethodSymbol member1, MethodSymbol member2, TypeCompareKind typeComparison)

Are all consumers passing the right TypeCompareKind for function pointers? #Closed

Refers to: src/Compilers/CSharp/Portable/Symbols/MemberSignatureComparer.cs:463 in 3d33fe4. [](commit_id = 3d33fe4, deletion_comment = False)

AlekseyTs · 2020-05-16T00:16:59Z

Done with review pass (iteration 7) #Closed

333fred · 2020-05-18T21:00:52Z

    public static bool HaveSameReturnTypes(MethodSymbol member1, MethodSymbol member2, TypeCompareKind typeComparison)

We could actually remove this API. There are no consumers.

In reply to: 629557451 [](ancestors = 629557451)

Refers to: src/Compilers/CSharp/Portable/Symbols/MemberSignatureComparer.cs:463 in 3d33fe4. [](commit_id = 3d33fe4, deletion_comment = False)

Added additional documentation for the TypeCompareKind flag, and targetted tests. Added more testing of other scenarios.

333fred · 2020-05-18T23:33:42Z

@AlekseyTs addressed feedback.

In reply to: 629557943 [](ancestors = 629557943)

AlekseyTs · 2020-05-19T01:59:22Z

src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerTypeSymbol.cs

+        /// for types that only differ by the type of ref they have.
+        /// </summary>
+        internal static RefKind GetRefKindForHashCode(RefKind refKind)
+            => refKind switch


refKind switch [](start = 15, length = 14)

I think it would be more robust and clearer to base the hash code on the value (refKind == RefKind.None). There would be clear correspondence to the equality evaluation, consistency between implementation of both APIs would be obvious and wouldn't require any additional maintenance when the set of RefKinds is extended. #Closed

There is also an option to not adjust hash code based on ref kinds.

In reply to: 426986569 [](ancestors = 426986569)

AlekseyTs · 2020-05-19T02:08:57Z

Done with review pass (iteration 8) #Closed

…RefKindEquals.

333fred · 2020-05-19T18:39:47Z

@AlekseyTs address feedback.

In reply to: 630534288 [](ancestors = 630534288)

AlekseyTs

LGTM (iteration 9), assuming CI is passing.

333fred · 2020-05-19T19:02:42Z

@dotnet/roslyn-compiler for a second review. I'm going to hold off on rebasing until reviews are done.

333fred · 2020-05-20T16:38:58Z

@dotnet/roslyn-compiler for a second review please.

cston · 2020-05-20T17:06:52Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs

+                Diagnostic(ErrorCode.ERR_CantChangeReturnTypeOnOverride, "M2").WithArguments("Derived.M2()", "Base.M2()", $"delegate*<{refKindString(refKind1)}string, void>").WithLocation(10, 48 + refKind2.Length)
+            );
+
+            static string refKindString(string orig) => orig == " " ? "" : orig;


refKindString [](start = 26, length = 13)

Could this local function be removed if the RefKind.None cases were "" rather than " "? #Resolved

cston · 2020-05-20T17:11:10Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs

+            var comp = CreateCompilationWithFunctionPointers(@"
+unsafe class Base
+{
+    protected virtual void M1(delegate*<(int, string)> ptr) {{}}


{{}} [](start = 60, length = 4)

Is the inner {} needed? Same question for tests below. #Resolved

cston · 2020-05-20T17:19:00Z

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

+
+            var b = comp2.GetMember("B").GetPublicSymbol();
+
+            Assert.Throws<ArgumentException>(() => ((Compilation)comp2).IsSymbolAccessibleWithin(ptr1, b));


IsSymbolAccessibleWithin [](start = 72, length = 24)

Why does this throw ArgumentException rather than returning false? #Resolved

Because A isn't from any reference of comp2.

In reply to: 428179712 [](ancestors = 428179712)

cston · 2020-05-20T17:21:23Z

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

+                Diagnostic(ErrorCode.ERR_InvalidQM, "b ? ptr5 : ptr8").WithArguments("delegate*<string>", "delegate*<string?>").WithLocation(22, 13),
+                // (23,24): warning CS8619: Nullability of reference types in value of type 'delegate*<string?>' doesn't match target type 'delegate*<string>'.
+                //         _ = b ? ptr7 : ptr8;
+                Diagnostic(ErrorCode.WRN_NullabilityMismatchInAssignment, "ptr8").WithArguments("delegate*<string?>", "delegate*<string>").WithLocation(23, 24)
            );


); [](start = 12, length = 2)

Are we testing mismatch of parameter types in addition to return types? #Resolved

cston · 2020-05-20T17:21:47Z

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

+        public void NormalizeTaskTypes_FunctionPointers()
+        {
+
+            string source =


Blank line. #Resolved

cston · 2020-05-20T17:22:01Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs

+        public void Override_SingleDimensionArraySizesInMetadata()
+        {
+
+            var il = @"


Blank line. #Resolved

cston · 2020-05-20T17:28:01Z

src/Compilers/CSharp/Test/Symbol/Symbols/FunctionPointerTypeSymbolTests.cs

+            Assert.Equal(ptr1Ref.GetHashCode(), ptr1RefReadonly.GetHashCode());
+            Assert.Equal(ptr2Ref.GetHashCode(), ptr2In.GetHashCode());
+            Assert.Equal(ptr2Ref.GetHashCode(), ptr2Out.GetHashCode());
+        }


} [](start = 8, length = 1)

Are we testing symbolEqualityComparer.GetHashCode()? #Resolved

cston · 2020-05-20T18:30:00Z

src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs

+
+            comp.VerifyDiagnostics(
+                // (16,29): warning CS8610: Nullability of reference types in type of parameter 'ptr' doesn't match overridden member.
+                //     protected override void M1(delegate*<string> ptr) {{}}


{{}} [](start = 73, length = 4)

Minor: Comments are stale, here and below. #Resolved

ghost

Auto-approval

333fred · 2020-05-20T22:05:26Z

Debug integration test failure is #43967.

333fred added 7 commits May 14, 2020 10:00

Add public API access check support.

6b6689f

Function pointer symbols cannot be referenced by name.

cae7f81

A PointerType's sort order is never usable today.

8c9f326

Return true for IsTypeOrTypeAlias for function pointers.

5d5dcc5

Support normalizing task-like types in function pointer types.

3f94e67

Support for overloading and overriding signatures with function point…

447d87f

…ers.

Add nullable tests

3d33fe4

333fred requested a review from a team as a code owner May 14, 2020 17:13

333fred added Area-Compilers Feature - Function Pointers Adding Function Pointers labels May 14, 2020

333fred requested a review from AlekseyTs May 14, 2020 17:13

333fred mentioned this pull request May 14, 2020

Open Issues in "Function Pointers" #39865

Closed

18 tasks

AlekseyTs reviewed May 15, 2020

View reviewed changes

AlekseyTs reviewed May 16, 2020

View reviewed changes

333fred mentioned this pull request May 18, 2020

IsSymbolAccessibleWithin does not check all type arguments for inaccessibility #44345

Open

Respond to PR feedback.

3f827dd

Added additional documentation for the TypeCompareKind flag, and targetted tests. Added more testing of other scenarios.

AlekseyTs reviewed May 19, 2020

View reviewed changes

Adjust correspondence in the GetRefKindForHashCode function to match …

ed27295

…RefKindEquals.

AlekseyTs approved these changes May 19, 2020

View reviewed changes

cston reviewed May 20, 2020

View reviewed changes

Adjust tests per feedback.

232b02e

cston reviewed May 20, 2020

View reviewed changes

cston approved these changes May 20, 2020

View reviewed changes

333fred added the auto-merge label May 20, 2020

ghost approved these changes May 20, 2020

View reviewed changes

Fixed formatting.

b8418fb

jaredpar merged commit 64d1878 into dotnet:features/function-pointers May 20, 2020

333fred deleted the test branch May 20, 2020 22:45


		var b = comp2.GetMember("B").GetPublicSymbol();

		Assert.Throws<ArgumentException>(() => ((Compilation)comp2).IsSymbolAccessibleWithin(ptr1, b));

Test plan followup #44257

Test plan followup #44257

Conversation

333fred commented May 14, 2020 • edited by jcouv Loading

333fred commented May 15, 2020

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

333fred May 18, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs commented May 15, 2020 • edited Loading

AlekseyTs commented May 15, 2020 • edited Loading

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

333fred May 18, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

AlekseyTs May 15, 2020 • edited Loading

Choose a reason for hiding this comment

AlekseyTs May 16, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs commented May 16, 2020 • edited Loading

AlekseyTs commented May 16, 2020 • edited Loading

333fred commented May 18, 2020

333fred commented May 18, 2020

AlekseyTs May 19, 2020 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs commented May 19, 2020 • edited Loading

333fred commented May 19, 2020

AlekseyTs left a comment

Choose a reason for hiding this comment

333fred commented May 19, 2020

333fred commented May 20, 2020

cston May 20, 2020 • edited by 333fred Loading

Choose a reason for hiding this comment

cston May 20, 2020 • edited by 333fred Loading

Choose a reason for hiding this comment

cston May 20, 2020 • edited by 333fred Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

cston May 20, 2020 • edited by 333fred Loading

Choose a reason for hiding this comment

cston May 20, 2020 • edited by 333fred Loading

Choose a reason for hiding this comment

cston May 20, 2020 • edited by 333fred Loading

Choose a reason for hiding this comment

cston May 20, 2020 • edited by 333fred Loading

Choose a reason for hiding this comment

cston May 20, 2020 • edited by 333fred Loading

333fred commented May 14, 2020 •

edited by jcouv

Loading

AlekseyTs May 15, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

333fred May 18, 2020 •

edited

Loading

AlekseyTs commented May 15, 2020 •

edited

Loading

AlekseyTs commented May 15, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

333fred May 18, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

AlekseyTs May 15, 2020 •

edited

Loading

AlekseyTs May 16, 2020 •

edited

Loading

AlekseyTs commented May 16, 2020 •

edited

Loading

AlekseyTs commented May 16, 2020 •

edited

Loading

AlekseyTs May 19, 2020 •

edited

Loading

AlekseyTs commented May 19, 2020 •

edited

Loading

cston May 20, 2020 •

edited by 333fred

Loading

cston May 20, 2020 •

edited by 333fred

Loading

cston May 20, 2020 •

edited by 333fred

Loading

cston May 20, 2020 •

edited by 333fred

Loading

cston May 20, 2020 •

edited by 333fred

Loading

cston May 20, 2020 •

edited by 333fred

Loading

cston May 20, 2020 •

edited by 333fred

Loading

cston May 20, 2020 •

edited by 333fred

Loading