Non-nullable fields of default struct value should be treated as nullable #32304

cston · 2019-01-09T22:29:31Z

jcouv · 2019-01-09T23:49:56Z

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

@@ -17481,6 +17484,77 @@ static void F2(bool b, IOut<object, string> x2, IOut<object?, string?> y2)
            comp.VerifyTypes();
        }

+#if false


Is this intentional? If it is please add a comment and link to follow-up issue. #Resolved

jcouv · 2019-01-09T23:50:17Z

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

@@ -20775,6 +20849,65 @@ static void G3(B<object>.IOut<string> x3, B<object?>.IOut<string?> y3)
            comp.VerifyTypes();
        }

+#if false


Same here #Resolved

jcouv · 2019-01-10T00:00:41Z

src/Compilers/CSharp/Portable/FlowAnalysis/DefiniteAssignment.VariableIdentifier.cs

@@ -49,7 +48,7 @@ public override bool Equals(object obj)
                return !left.Equals(right);
            }

-            internal string GetDebuggerDisplay()


GetDebuggerDisplay [](start = 28, length = 18)

I'm curious, why the change?
Just want to confirm it's not because DebuggerDisplay isn't working in dev16 (I've already filled a bug on that). #Closed

Changed because ToString() is used in the EE for instances in a collection. #Closed

cston · 2019-01-10T00:01:55Z

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

+    }
+}";
+            var comp = CreateCompilation(source, options: WithNonNullTypesTrue());
+            // PROTOTYPE: Missing // 2


PROTOTYPE [](start = 15, length = 9)

Need to log a bug if not resolved in this PR. #Resolved

cston · 2019-01-10T00:02:44Z

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

+    }
+}";
+            var comp = CreateCompilation(source, options: WithNonNullTypesTrue());
+            // PROTOTYPE: Missing // 1


PROTOTYPE [](start = 15, length = 9)

Same issue as earlier. #Closed

jcouv · 2019-01-10T18:04:21Z

docs/features/nullable-reference-types.md

 ```
+If `T` is a value type, `default(T)` is `T` and any non-nullable fields in `T` are maybe null.


any non-nullable fields [](start = 48, length = 23)

Perhaps "all non-struct fields"?
int?, string? or T field would also get a nullable null-state, I assume. #Closed

jcouv · 2019-01-10T18:05:05Z

docs/features/nullable-reference-types.md

 ```
+If `T` is a value type, `default(T)` is `T` and any non-nullable fields in `T` are maybe null.
+If `T` is a value type, `new T()` is equivalent to `default(T)`.


new T() is equivalent to default(T) [](start = 24, length = 39)

Does this depend on whether we're using a default constructor, or a user-defined one? #Closed

This only applies to the default parameter-less constructor that cannot be overridden for structs.

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

Ah, I didn't know they couldn't be overridden. Thanks

In reply to: 246865325 [](ancestors = 246865325,246863817)

jcouv · 2019-01-10T18:13:36Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -797,7 +831,9 @@ private void InheritNullableStateOfMember(int targetContainerSlot, int valueCont
            if (fieldOrPropertyType.IsReferenceType || fieldOrPropertyType.IsNullableType())
            {
                int targetMemberSlot = GetOrCreateSlot(member, targetContainerSlot);
-                NullableAnnotation value = fieldOrPropertyType.NullableAnnotation;
+                NullableAnnotation value = (isDefaultValue && fieldOrPropertyType.IsReferenceType) ?


fieldOrPropertyType.IsReferenceType [](start = 62, length = 35)

~~Should this be ... && (!fieldOrPropertType.IsValueType || fieldOrProperty.IsNullableType())?~~

I think my proposal was wrong, but I still feel there is a problem here. Probably with unconstrained T. #ByDesign

If the member type is a nullable value type, fieldOrPropertyType.NullableAnnotation should return Nullable already.

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

From our discussion, it's not obvious how T works

In reply to: 246867516 [](ancestors = 246867516,246866495)

A member with a unconstrained type parameter type is already considered maybe null. The only cases we need to handle specifically here are members where the type is declared as not nullable.

In reply to: 246871048 [](ancestors = 246871048,246867516,246866495)

There is a related issue when copying not-nullable state for unconstrained types though. Logged #32338. Thanks.

In reply to: 246874741 [](ancestors = 246874741,246871048,246867516,246866495)

jcouv · 2019-01-10T18:19:22Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -1290,7 +1329,7 @@ private void SetResult(BoundExpression node)
            _resultType = TypeSymbolWithAnnotations.Create(node.Type);
        }

-        private ObjectCreationPlaceholderLocal GetOrCreateObjectCreationPlaceholder(BoundExpression node)
+        private int GetOrCreateObjectCreationPlaceholder(BoundExpression node)


GetOrCreateObjectCreationPlaceholder [](start = 20, length = 36)

Perhaps GetOrCreateObjectCreationPlaceholderSlot ? #Resolved

jcouv · 2019-01-10T18:30:42Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -928,13 +964,11 @@ private void EnterParameter(ParameterSymbol parameter, TypeSymbolWithAnnotations
            {
                if (EmptyStructTypeCache.IsTrackableStructType(parameterType.TypeSymbol))
                {
-                    InheritNullableStateOfTrackableStruct(parameterType.TypeSymbol, slot, valueSlot: -1, isByRefTarget: parameter.RefKind != RefKind.None, slotWatermark: GetSlotWatermark());
+                    InheritNullableStateOfTrackableStruct(parameterType.TypeSymbol, slot, valueSlot: -1, isDefaultValue: false, isByRefTarget: parameter.RefKind != RefKind.None, slotWatermark: GetSlotWatermark());


isDefaultValue: false, [](start = 105, length = 22)

What about void M(string s = default)?
I think we report a warning already, but in terms of null-state the optional value should probably still count. #Resolved

Good catch, thanks.

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

jcouv · 2019-01-10T18:32:41Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -1090,7 +1124,7 @@ private static bool IsTypeParameterDisallowingAnnotation(TypeSymbol typeOpt)
        public override BoundNode VisitLocal(BoundLocal node)
        {
            var local = node.LocalSymbol;
-            int slot = GetOrCreateSlot(local);
+            int slot = GetOrCreateSlot(local, createIfMissing: false);


, createIfMissing: false [](start = 44, length = 24)

Does this matter? Consider removing for simplicity. #ByDesign

This shouldn't matter (since a slot for the local should have been created already), but it seems reasonable to pass false explicitly so the intent is clear that a slot should not be created here.

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

jcouv

LGTM Thanks (iteration 5)

cston · 2019-01-10T18:43:46Z

@dotnet/roslyn-compiler, please review.

jcouv · 2019-01-10T21:43:04Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                        parameterType.TypeSymbol,
+                        slot,
+                        valueSlot: -1,
+                        isDefaultValue: parameter.ExplicitDefaultConstantValue?.IsNull == true,


parameter.ExplicitDefaultConstantValue?.IsNull == true, [](start = 40, length = 55)

Does that work for void M(T t = default)? #ByDesign

We're only interested in cases where parameter.Type is a trackable struct. (See outer if.)

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

AlekseyTs · 2019-01-10T21:43:53Z

src/Compilers/CSharp/Portable/FlowAnalysis/LocalDataFlowPass.cs

@@ -91,11 +91,11 @@ protected int VariableSlot(Symbol symbol, int containingSlot = 0)
        /// <summary>
        /// Force a variable to have a slot.  Returns -1 if the variable has an empty struct type.
        /// </summary>
-        protected int GetOrCreateSlot(Symbol symbol, int containingSlot = 0)
+        protected int GetOrCreateSlot(Symbol symbol, int containingSlot = 0, bool createIfMissing = true)


createIfMissing [](start = 82, length = 15)

It feels like the "createIfMissing" parameter is specific to tuples, but the name doesn't reflect the fact. This might be confusing to consumers. For example, one might assume that, unless we already allocated a slot, this function won't allocate it when false is passed for createIfMissing parameter. However, it doesn't look like this is the case. #Closed

AlekseyTs · 2019-01-10T21:55:29Z

src/Compilers/CSharp/Portable/FlowAnalysis/LocalDataFlowPass.cs

@@ -162,16 +162,10 @@ private int DescendThroughTupleRestFields(ref Symbol symbol, int containingSlot,
                        return -1;
                    }

-                    if (forceContainingSlotsToExist)
+                    containingSlot = GetOrCreateSlot(restField, containingSlot, createIfMissing);


containingSlot = GetOrCreateSlot(restField, containingSlot, createIfMissing); [](start = 20, length = 77)

Is propagating createIfMissing has any real effect here? It looks like restField is coming from an underlying named type. Therefore, it cannot be a TupleFieldSymbol. Therefore, the DescendThroughTupleRestFields call in the GetOrCreateSlot above will be a NoOp regardless of the value passed in createIfMissing.
If these observations are correct, then it means that now createIfMissing has no effect on the "result" of this function, but it looks like the forceContainingSlotsToExist parameter used to have an effect.
#Closed

AlekseyTs · 2019-01-10T21:58:18Z

src/Compilers/CSharp/Portable/FlowAnalysis/LocalDataFlowPass.cs

@@ -82,7 +82,7 @@ protected override void Free()
        /// </summary>
        protected int VariableSlot(Symbol symbol, int containingSlot = 0)
        {
-            containingSlot = DescendThroughTupleRestFields(ref symbol, containingSlot, forceContainingSlotsToExist: false);
+            containingSlot = DescendThroughTupleRestFields(ref symbol, containingSlot, createIfMissing: false);


createIfMissing: false [](start = 87, length = 22)

Does passing false really makes any difference given the changes in DescendThroughTupleRestFields function? #Closed

AlekseyTs · 2019-01-10T22:13:06Z

src/Compilers/CSharp/Portable/FlowAnalysis/LocalDataFlowPass.cs

        {
            if (symbol.Kind == SymbolKind.RangeVariable) return -1;

-            containingSlot = DescendThroughTupleRestFields(ref symbol, containingSlot, forceContainingSlotsToExist: true);
+            containingSlot = DescendThroughTupleRestFields(ref symbol, containingSlot, createIfMissing);


containingSlot = DescendThroughTupleRestFields(ref symbol, containingSlot, createIfMissing); [](start = 12, length = 92)

I understand that this is an existing logic. It looks like DescendThroughTupleRestFields can return -1. Does it make sense to continue in this case? It looks like we will go ahead and allocate a new slot for the member even in this case. It also looks like that slot is going to be shared across distinct original containers, effectively treating members of different containers as the same storage location. #Closed

AlekseyTs · 2019-01-10T22:30:56Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                        var type = ((BoundDefaultExpression)node).Type;
+                        if (EmptyStructTypeCache.IsTrackableStructType(type))
+                        {
+                            int slot = GetOrCreateObjectCreationPlaceholderSlot(node);


int slot = GetOrCreateObjectCreationPlaceholderSlot(node); [](start = 28, length = 58)

It feels like there is an inconsistency between when we create placeholder locals for the default expression and for an object creation. I think it would be better to use the same approach for all such cases. For example, here we would simply do what is done for the case BoundKind.ObjectCreationExpression: and the code that is currently here could be moved to VisitDefault etc. #Closed

Yes, that is necessary to handle split states as well.

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

AlekseyTs · 2019-01-10T22:34:29Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

                    {
                        int slot = _lastConditionalAccessSlot;
                        _lastConditionalAccessSlot = -1;
                        return slot;
                    }
-                    break;
+                default:
+                    return base.MakeSlot(node);


return base.MakeSlot(node); [](start = 20, length = 27)

This used to be called for all cases that don't return, now we always return -1 for scenarios like that. Is this the right thing to do? #Closed

Yes, I believe so. There is no overlap between the cases here and in the base.

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

AlekseyTs · 2019-01-10T22:43:19Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs


-            bool isDefaultOfUnconstrainedTypeParameter(BoundExpression expr)
+        private static bool IsDefaultOfUnconstrainedTypeParameter(BoundExpression expr)


IsDefaultOfUnconstrainedTypeParameter [](start = 28, length = 37)

It looks like this function is called only from the original call site. Why make it a member vs. a local function? #Closed

To allow grouping the two IsDefault... methods so the similarity is more obvious.

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

AlekseyTs · 2019-01-10T22:54:09Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                        parameterType.TypeSymbol,
+                        slot,
+                        valueSlot: -1,
+                        isDefaultValue: parameter.ExplicitDefaultConstantValue?.IsNull == true,


isDefaultValue: parameter.ExplicitDefaultConstantValue?.IsNull == true, [](start = 24, length = 71)

Is this going to properly handle structures? #Closed

parameter.ExplicitDefaultConstantValue.IsNull is true for default(S) and new S().

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

parameter.ExplicitDefaultConstantValue.IsNull is true for default(S) and new S().

Judging by the doc comments on ExplicitDefaultConstantValue property, this is not intended behavior of the API.

In reply to: 246955015 [](ancestors = 246955015,246951009)

Added a missing default value test, and checked the implementations of ExplicitDefaultConstantValue look reasonable.

In reply to: 246959155 [](ancestors = 246959155,246955015,246951009)

AlekseyTs · 2019-01-10T22:56:55Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -832,13 +868,13 @@ private void InheritNullableStateOfMember(int targetContainerSlot, int valueCont
                    int valueMemberSlot = -1;
                    if (valueContainerSlot > 0)
                    {
-                        int slot = GetOrCreateSlot(member, valueContainerSlot);
+                        int slot = GetOrCreateSlot(member, valueContainerSlot, createIfMissing: false);


createIfMissing: false [](start = 79, length = 22)

I am not sure if passing this value is going to have any useful effect. If we are not interested in allocating new slots, perhaps we should use VariableSlot API instead. #Closed

AlekseyTs · 2019-01-10T22:58:36Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -1090,7 +1130,7 @@ private static bool IsTypeParameterDisallowingAnnotation(TypeSymbol typeOpt)
        public override BoundNode VisitLocal(BoundLocal node)
        {
            var local = node.LocalSymbol;
-            int slot = GetOrCreateSlot(local);
+            int slot = GetOrCreateSlot(local, createIfMissing: false);


createIfMissing: false [](start = 46, length = 22)

I am not sure if passing this value is going to have any useful effect. If we are not interested in allocating new slots, perhaps we should use VariableSlot API instead. #Closed

AlekseyTs · 2019-01-10T23:00:23Z

        LocalSymbol receiver = null;

It looks like receiver is never changed to anything else. #Closed

Refers to: src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs:1225 in 50416ca. [](commit_id = 50416ca, deletion_comment = False)

AlekseyTs · 2019-01-10T23:03:30Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

+                            type,
+                            slot,
+                            valueSlot: -1,
+                            isDefaultValue: (node as BoundObjectCreationExpression)?.Constructor.IsImplicitConstructor == true,


(node as BoundObjectCreationExpression)?.Constructor.IsImplicitConstructor == true [](start = 44, length = 82)

This doesn't look like a test for a Default Value Type Constructor. Am I misinterpreting the intent? #Closed

Changed.

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

AlekseyTs · 2019-01-10T23:05:28Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -3940,7 +3984,7 @@ private void VisitThisOrBaseReference(BoundExpression node)
        public override BoundNode VisitParameter(BoundParameter node)
        {
            var parameter = node.ParameterSymbol;
-            int slot = GetOrCreateSlot(parameter);
+            int slot = GetOrCreateSlot(parameter, createIfMissing: false);


createIfMissing: false [](start = 50, length = 22)

I am not sure if passing this value is going to have any useful effect. If we are not interested in allocating new slots, perhaps we should use VariableSlot API instead. #Closed

AlekseyTs · 2019-01-10T23:07:53Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -4301,7 +4345,7 @@ private void VisitMemberAccess(BoundExpression node, BoundExpression receiverOpt
                    if (!resultType.IsValueType || resultType.IsNullableType())
                    {
                        int containingSlot = getReceiverSlot();
-                        int slot = (containingSlot < 0) ? -1 : GetOrCreateSlot(member, containingSlot);
+                        int slot = (containingSlot < 0) ? -1 : GetOrCreateSlot(member, containingSlot, createIfMissing: false);


createIfMissing: false [](start = 103, length = 22)

I am not sure if passing this value is going to have any useful effect. If we are not interested in allocating new slots, perhaps we should use VariableSlot API instead. But do we really want to skip allocating the slot and fail to adjust resultType? #Closed

AlekseyTs · 2019-01-10T23:10:11Z

src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs

@@ -771,7 +804,7 @@ private void ReportDiagnostic(ErrorCode errorCode, SyntaxNode syntaxNode, params
            }
        }

-        private void InheritNullableStateOfTrackableStruct(TypeSymbol targetType, int targetSlot, int valueSlot, bool isByRefTarget, int slotWatermark)
+        private void InheritNullableStateOfTrackableStruct(TypeSymbol targetType, int targetSlot, int valueSlot, bool isDefaultValue, bool isByRefTarget, int slotWatermark)


bool isDefaultValue [](start = 113, length = 19)

If we are propagating this flag separately anyway, why do we need slots for the "fake" state? #Closed

As we discussed, slots are needed for direct member access (e.g.: default(S).F.ToString()), although that is not a particularly compelling scenario to handle.

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

AlekseyTs · 2019-01-10T23:40:32Z

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

+        where U : class
+        where V : struct
+    {
+        new S<T>().F/*T:T*/.ToString(); // 1


new S() [](start = 8, length = 10)

Do we have a test covering non-default value type constructors and explicitly defined parameter-less constructors (legal in metadata I think)? #Closed

AlekseyTs · 2019-01-10T23:56:17Z

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

+        where V : struct
+    {
+        new S<T>().F/*T:T*/.ToString(); // 1
+        new S<U>().F/*T:U?*/.ToString(); // 2


new S() [](start = 8, length = 10)

Do we have a test covering combination of default value type constructors with object member initializers? #Closed

AlekseyTs · 2019-01-11T00:07:12Z

Done review pass (iteration 11) #Closed

AlekseyTs

LGTM (iteration 13)

default struct fields should be nullable

06b295a

cston requested a review from a team as a code owner January 9, 2019 22:29

jcouv added Area-Compilers Feature - Nullable Reference Types Nullable Reference Types labels Jan 9, 2019

jcouv added this to the 16.0.P3 milestone Jan 9, 2019

jcouv reviewed Jan 9, 2019

View reviewed changes

Fix tests

ceb6e75

jcouv reviewed Jan 10, 2019

View reviewed changes

cston commented Jan 10, 2019

View reviewed changes

cston added 3 commits January 10, 2019 08:54

Fix tests

1a12000

Revert change

67a95a4

Update spec-let

f18ea79

jcouv reviewed Jan 10, 2019

View reviewed changes

PR feedback

b6c3225

jcouv reviewed Jan 10, 2019

View reviewed changes

jcouv approved these changes Jan 10, 2019

View reviewed changes

PR feedback

50416ca

jcouv reviewed Jan 10, 2019

View reviewed changes

AlekseyTs reviewed Jan 10, 2019

View reviewed changes

Fix tests

60e8b48

AlekseyTs reviewed Jan 10, 2019

View reviewed changes

Remove createIfMissing

4a17e37

AlekseyTs reviewed Jan 10, 2019

View reviewed changes

cston added 2 commits January 10, 2019 15:44

PR feedback

e98bb51

Add parameter-less constructor test

49ca8c4

AlekseyTs reviewed Jan 10, 2019

View reviewed changes

cston added 2 commits January 10, 2019 16:08

Add object initializer test

a651c59

Add missing default parameter value test

820753c

jcouv self-assigned this Jan 11, 2019

AlekseyTs approved these changes Jan 11, 2019

View reviewed changes

cston merged commit a2d838e into dotnet:master Jan 11, 2019

cston deleted the 30731 branch January 11, 2019 19:20

		```
		If `T` is a value type, `default(T)` is `T` and any non-nullable fields in `T` are maybe null.


		bool isDefaultOfUnconstrainedTypeParameter(BoundExpression expr)
		private static bool IsDefaultOfUnconstrainedTypeParameter(BoundExpression expr)

Non-nullable fields of default struct value should be treated as nullable #32304

Non-nullable fields of default struct value should be treated as nullable #32304

Conversation

cston commented Jan 9, 2019

jcouv Jan 9, 2019 • edited by cston Loading

Choose a reason for hiding this comment

jcouv Jan 9, 2019 • edited by cston Loading

Choose a reason for hiding this comment

jcouv Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

cston Jan 10, 2019 • edited by jcouv Loading

Choose a reason for hiding this comment

cston Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

cston Jan 10, 2019 • edited by jcouv Loading

Choose a reason for hiding this comment

jcouv Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

jcouv Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jcouv Jan 10, 2019 • edited by cston 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

jcouv Jan 10, 2019 • edited by cston Loading

Choose a reason for hiding this comment

jcouv Jan 10, 2019 • edited by cston Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jcouv Jan 10, 2019 • edited by cston Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

jcouv left a comment

Choose a reason for hiding this comment

cston commented Jan 10, 2019

jcouv Jan 10, 2019 • edited by cston Loading

Choose a reason for hiding this comment

cston Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • 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 Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

AlekseyTs commented Jan 10, 2019 • edited Loading

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

AlekseyTs Jan 10, 2019 • edited Loading

Choose a reason for hiding this comment

cston Jan 11, 2019 • edited Loading

jcouv Jan 9, 2019 •

edited by cston

Loading

jcouv Jan 9, 2019 •

edited by cston

Loading

jcouv Jan 10, 2019 •

edited

Loading

cston Jan 10, 2019 •

edited by jcouv

Loading

cston Jan 10, 2019 •

edited

Loading

cston Jan 10, 2019 •

edited by jcouv

Loading

jcouv Jan 10, 2019 •

edited

Loading

jcouv Jan 10, 2019 •

edited

Loading

jcouv Jan 10, 2019 •

edited by cston

Loading

jcouv Jan 10, 2019 •

edited by cston

Loading

jcouv Jan 10, 2019 •

edited by cston

Loading

jcouv Jan 10, 2019 •

edited by cston

Loading

jcouv Jan 10, 2019 •

edited by cston

Loading

cston Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs commented Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

cston Jan 11, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs Jan 10, 2019 •

edited

Loading

AlekseyTs commented Jan 11, 2019 •

edited

Loading