Track nullability of unconstrained type parameters by 333fred · Pull Request #28956 · dotnet/roslyn

333fred · 2018-07-31T02:09:40Z

@jcouv @cston @dotnet/roslyn-compiler for review.

cston · 2018-07-31T03:14:56Z

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

            }
        }

+        private TypeSymbolWithAnnotations GetAdjustedType(TypeSymbolWithAnnotations initialType)


static #Resolved

cston · 2018-07-31T03:19:08Z

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

                }
            }
-            else if (!operatorKind.IsDynamic() && resultType.IsReferenceType == true)
+            else if (!operatorKind.IsDynamic() && (resultType.IsReferenceType || resultType.IsUnconstrainedTypeParameter()))


Can this be simplified to && !resultType.IsValueType)? Same comment elsewhere.

If not, please extract a IsReferenceTypeOrUnconstrainedTypeParameter() helper.
#Resolved

cston · 2018-07-31T03:26:01Z

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

 ", NonNullTypesTrue, NonNullTypesAttributesDefinition }, parseOptions: TestOptions.Regular8);

-            c.VerifyDiagnostics(
-                // (22,22): warning CS8625: Cannot convert null literal to non-nullable reference or unconstrained type parameter.


// (22,22): warning CS8625: Cannot convert null literal to non-nullable reference or unconstrained type parameter. [](start = 16, length = 114)

This warning is correct. For instance if T is string, this is a warning for return (string)null;. #Resolved

cston · 2018-07-31T03:59:58Z

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

-" + EnsuresNotNullAttributeDefinition, parseOptions: TestOptions.Regular8);
+", EnsuresNotNullAttributeDefinition, NonNullTypesAttributesDefinition, NonNullTypesTrue }, parseOptions: TestOptions.Regular8);

            // PROTOTYPE(NullableReferenceTypes): We're not tracking unconstrained generic types


// PROTOTYPE(NullableReferenceTypes) [](start = 12, length = 36)

Can remove comment. #Closed

cston · 2018-07-31T04:00:35Z

    // PROTOTYPE(NullableReferenceTypes): Should not warn for `default(T1)!.ToString()`.

Can remove comment. #Closed

Refers to: src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs:29561 in f3a36b9. [](commit_id = f3a36b9, deletion_comment = False)

cston · 2018-07-31T04:02:39Z

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

                // (6,39): warning CS8625: Cannot convert null literal to non-nullable reference or unconstrained type parameter.
                //     static async Task<string> F1() => null;
                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(6, 39),
-                // (8,43): warning CS8625: Cannot convert null literal to non-nullable reference or unconstrained type parameter.


// (8,43): warning CS8625: Cannot convert null literal [](start = 16, length = 54)

It looks like these three warnings were correct. #Closed

cston · 2018-07-31T04:09:28Z

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

+                // (20,51): warning CS8600: Converting null literal or possible null value to non-nullable type.
+                //     static U F18<T, U>(T t) where U : class, T => (U)t;
+                Diagnostic(ErrorCode.WRN_ConvertingNullableToNonNullable, "(U)t").WithLocation(20, 51),
+                // prototype(NullableReferenceTypes): Should this be a warning, as there was already a nested warning about converting t to U?


prototype [](start = 19, length = 9)

PROTOTYPE #Pending

Still active.

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

cston · 2018-07-31T15:55:05Z

    [Fact(Skip = "TODO")]

Please enable this test and the one below. #Resolved

Refers to: src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs:36121 in f3a36b9. [](commit_id = f3a36b9, deletion_comment = False)

333fred · 2018-07-31T22:21:55Z

@cston addressed feedback. #Closed

cston · 2018-07-31T22:46:19Z

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

+        private static TypeSymbolWithAnnotations GetAdjustedType(TypeSymbolWithAnnotations initialType)
+        {
+            // If the initial type was an unconstrained type parameter, we want to treat it as nullable, overriding
+            // the annotated state.


Why not return IsNullable == true from the original TypeSymbolWithAnnotations? #Resolved

Because the original TWSA is from initial binding, and IsNullable does not return true.

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

Why not set treatUnconstrainedGenericsAsNullable: true in initial binding?

In reply to: 206722195 [](ancestors = 206722195,206707381)

Talked with @cston offline. We'll defer doing this for a later PR, I'll add a prototype comment to track.

In reply to: 206750233 [](ancestors = 206750233,206722195,206707381)

cston · 2018-07-31T22:57:37Z

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

 @"class C1<T1>
 {
    static object? NullableObject() => null;
-    static T1 F1() => default; // warn: return type T1 may be non-null


// warn: return type T1 may be non-null [](start = 31, length = 39)

Please add these comments back. #Closed

cston · 2018-08-01T04:10:50Z

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

        internal static TypeSymbolWithAnnotations CreateUnannotated(INonNullTypesContext nonNullTypesContext, TypeSymbol typeSymbol, ImmutableArray<CustomModifier> customModifiers = default)
        {
-            return Create(typeSymbol, nonNullTypesContext, isAnnotated: false, customModifiers.NullToEmpty());
+            return Create(typeSymbol, nonNullTypesContext, isAnnotated: false, treatUnconstrainedGenericsAsNullable: false, customModifiers.NullToEmpty());


treatUnconstrainedGenericsAsNullable [](start = 79, length = 36)

Perhaps treatUnconstrainedTypeParameterAsNullable, since this applies to explicit type parameter instances, not nested type parameters. #Resolved

333fred · 2018-08-01T17:26:12Z

@cston addressed feedback. #Closed

cston · 2018-08-01T17:29:13Z

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


        // PROTOTYPE(NullableReferenceTypes): [Obsolete("Use explicit NonNullTypes context")]
-        public static TypeSymbolWithAnnotations Create(TypeSymbol typeSymbol, bool? isNullableIfReferenceType)
+        public static TypeSymbolWithAnnotations Create(TypeSymbol typeSymbol, bool? isNullableIfReferenceType, bool treatUnconstrainedGenericsAsNullable = false)


treatUnconstrainedGenericsAsNullable [](start = 116, length = 36)

treatUnconstrainedTypeParameterAsNullable #Resolved

cston · 2018-08-01T17:57:56Z

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

    static T1 F2() => default(T1); // warn: return type T1 may be non-null
    static void F4()
    {
-        T1 t1 = (T1)NullableObject(); // warn: T1 may be non-null


// warn: T1 may be non-null [](start = 38, length = 27)

Should be a warning in each case. #Closed

cston · 2018-08-01T18:03:15Z

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

@@ -36173,60 +36156,74 @@ public void UnconstrainedTypeParameter_Return_03()
    static U F20<T, U>(T t) where U : T, new() => (U)t;
 }";


As we discussed offline, please add additional test cases when T and U are independent. Something like:

class C { static U F1<T, U>(T t) => (U)(object)t; static U F2<T, U>(T t) where U : class => (U)(object)t; static U F3<T, U>(T t) where U : struct => (U)(object)t; static U F4<T, U>(T t) where T : class => (U)(object)t; static U F5<T, U>(T t) where T : struct => (U)(object)t; } ``` #Resolved

cston · 2018-08-01T21:56:14Z

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

    static T3 F3() => new T3();
    static void F4()
    {
-        T3 t = (T3)NullableObject(); // warn: T3 may be non-null


// warn: T3 may be non-null [](start = 37, length = 27)

Should be a warning. Please add the comment back. #Closed

cston · 2018-08-01T21:56:21Z

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

    static T4 F2() => default(T4); // warn: return type T4 may be non-null
    static void F4()
    {
-        T4 t4 = (T4)NullableObject(); // warn: T4 may be non-null


// warn: T4 may be non-null [](start = 38, length = 27)

Should be a warning. Please add the comment back. #Closed

jcouv · 2018-08-03T22:51:21Z

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

+        // PROTOTYPE(NullableReferenceTypes): Consider setting treatUnconstrainedTypeParameterAsNullable during initial binding, and removing this method.
+        private static TypeSymbolWithAnnotations GetAdjustedType(TypeSymbolWithAnnotations initialType)
+        {
+            // If the initial type was an unconstrained type parameter, we want to treat it as nullable, overriding


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

Perhaps make this an xml doc instead.
Also, consider renaming to "FixUnconstrainedTypeParameters", as it gives some indication of purpose, whereas "adjusted type" provides no clue. #Closed

jcouv · 2018-08-03T22:55:13Z

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


            TypeSymbolWithAnnotations valueType = VisitRvalueWithResult(initializer);
-            TypeSymbolWithAnnotations type = local.Type;
+            TypeSymbolWithAnnotations type = GetAdjustedType(local.Type);


GetAdjustedType [](start = 45, length = 15)

I see that parameters and locals are covered. Can you also check that out variables and other variables (using, foreach, deconstruction, patterns, ...) behave correctly?
The let in LINQ also introduces variables, but LINQ is known to be unhandled at the moment. #Resolved

Hum, ignore foreach variables for now. They have bigger problems. #Resolved

jcouv · 2018-08-03T23:00:30Z

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

                var parameter = methodParameters[i];
                var parameterType = signatureParameters[i].Type;
-                _variableTypes[parameter] = parameterType;
+                _variableTypes[parameter] = GetAdjustedType(parameterType);


GetAdjustedType [](start = 44, length = 15)

Consider moving this into EnterParameter #Closed

jcouv · 2018-08-03T23:06:56Z

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

        {
            var method = (MethodSymbol)_member;
            var returnType = (_useMethodSignatureReturnType ? _methodSignatureOpt : method).ReturnType;
+            returnType = GetAdjustedType(returnType);


GetAdjustedType [](start = 25, length = 15)

This change doesn't seem obvious to me. Why do we need to adjust here? #Closed

We need to support T Foo<T>(T t) => t. We treat t as a T?, and there should be no warnings in this code, so we want to make sure that we're only warning on the places where t is being dereferenced. The scenario of T Foo<T>() => default(T) is covered by warning on all conversions of default to T.

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

jcouv · 2018-08-03T23:13:09Z

    public override void VisitForEachIterationVariables(BoundForEachStatement node)

📝 foreach variables probably need to be handled #Closed

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

jcouv · 2018-08-03T23:16:29Z

    private static bool IsNullable(TypeSymbolWithAnnotations typeOpt)

Not blocking this PR: consider making IsNullable and IsNonNullable local functions (or inlining them) in VisitReturnStatementNoAdjust since they only appear to be used there. #Closed

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

jcouv · 2018-08-03T23:22:47Z

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

-            bool reportedNullable = false;
-            if (returnTypeIsNonNullable || returnTypeIsUnconstrainedTypeParameter)
+            if (returnTypeIsNonNullable &&
+                !ReportNullAsNonNullableReferenceIfNecessary(node.ExpressionOpt) &&


ReportNullAsNonNullableReferenceIfNecessary [](start = 17, length = 43)

We have different handling for null literal (which will produce WRN_NullAsNonNullable) than for other nullable expressions (which produce WRN_NullReferenceReturn below).
@cston Do you still think that is valuable, or could we remove the call to ReportNullAsNonNullableReferenceIfNecessary here?

Never mind, we probably need this handling because of null being typeless? #Closed

jcouv · 2018-08-03T23:25:11Z

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

            {
                bool isTrackableStructType = EmptyStructTypeCache.IsTrackableStructType(type);
-                if (type.IsReferenceType || isTrackableStructType)
+                if (!type.IsValueType || isTrackableStructType)


IsValueType [](start = 26, length = 11)

Not directly related to this PR: I see that we use .IsReferenceType in a number of remaining places in NullableWalker (usually in conjunction with IsUnconstrainedTypeParameter). It may be good to take a peek to see if they might need to be revised too. #Resolved

jcouv · 2018-08-03T23:30:10Z

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

            //if (this.State.Reachable) // PROTOTYPE(NullableReferenceTypes): Consider reachability?
            {
-                _resultType = method.ReturnType;
+                _resultType = GetAdjustedType(method.ReturnType);


GetAdjustedType [](start = 30, length = 15)

I'm not sure about this. Just to confirm, here's a scenario:

T Copy<T>(T t) ... void M<U>(U u) { if (u == null) throw; var x = Copy(u); x.ToString(); // do we expect a warning here? } ``` #Resolved

I would not expect a warning here: we've done the null check on u, so it should be U!. It would be a different question if the T was constrained to be class?, but with unconstrained I think this should be fine.

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

jcouv · 2018-08-03T23:39:06Z

    private TypeSymbolWithAnnotations GetDeclaredLocalResult(LocalSymbol local)

Just to confirm: Why do we adjust in GetDeclaredParameterResult (a few lines below) but not in GetDeclaredLocalResult? #Resolved

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

jcouv · 2018-08-03T23:42:45Z

                (operandType.IsReferenceType || operandType.IsUnconstrainedTypeParameter());

📝 here's an example #Closed

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

jcouv

Done with review pass (iteration 6).

… into unconstrained-type-parameter-nullability * dotnet/features/NullableReferenceTypes: Include nullability in CheckConstraints (dotnet#28959) Use struct for TypeSymbolWithAnnotations (dotnet#28943) Publish Linux Test Results Force retest Migrate Linux tests to VSTS Port determinism fixes Make sure TLS 1.2 is used to fetch from https://dot.net Move to language version 8 Make mutex creation more robust Disable icacls use on Helix Disable leak detection tests on x64 VSTS YAML file

jcouv · 2018-08-06T21:52:47Z

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

                returnType;
        }

+        // Consider making these local functions.


Consider [](start = 11, length = 8)

nit: PROTOTYPE instead of comment, or remove #Resolved

cston · 2018-08-06T21:57:09Z

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


+        // PROTOTYPE(NullableReferenceTypes): Consider setting treatUnconstrainedTypeParameterAsNullable during initial binding, and removing this method.
+        /// <summary>
+        /// Adjust the given type, treating unconstrained type parameters as nullable if in the appropriate context. This overrides the current state


unconstrained type parameters [](start = 44, length = 29)

This comment, and the method name, imply all unconstrained type parameters in initialType are adjusted, but we're only adjusting initialType if it is simply an unconstrained type parameter. Consider using singular here and in method name. #Resolved

jcouv · 2018-08-06T21:57:16Z

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

+        }
+
+        [Fact]
+        public void UnconstrainedTypeParameter_OutVariable()


UnconstrainedTypeParameter_OutVariable [](start = 20, length = 38)

Sorry I wasn't clear. I think the interesting case for out var is the call-site.

F3(t, out T t2); // check null-state of t2 (do we reset to nullable, or do we use the state of variable `t`?)

We may already have such test. #Resolved

jcouv · 2018-08-06T21:58:34Z

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

+                // parameters as annotated during initial binding without causing cycles.
+
+                // Initial binding leaves unconstrained type parameters unannotated, NullableWalker will
+                // set treatUnconstrainedTypeParametersAsNullable where appropriate


treat [](start = 23, length = 5)

~~nit: missing space after "treat"~~ Never mind, I'm slow. #Closed

cston · 2018-08-06T22:31:55Z

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

            return _variableTypes.TryGetValue(local, out TypeSymbolWithAnnotations type) ?
                type :
                local.Type;
+                //UnconstrainedTypeParametersAsNullable(local.Type);


//UnconstrainedTypeParametersAsNullable(local.Type); [](start = 16, length = 52)

Does this need a comment? Or can it be removed? #Resolved

cston · 2018-08-06T22:33:15Z

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

+                // parameters as annotated during initial binding without causing cycles.
+
+                // Initial binding leaves unconstrained type parameters unannotated, NullableWalker will
+                // set treatUnconstrainedTypeParametersAsNullable where appropriate


TypeParameters [](start = 41, length = 14)

TypeParameter (singular) here and below. #Resolved

jcouv · 2018-08-06T22:58:35Z

    public void VarLocal_FromGenericMethod_WithUnnecessarySuppression()

Let's add a test like this (T Copy<T>(T t)) with an argument that is still generic (untested, and tested for null).
That should illustrate the question in VisitCall.
Then we can do the same with a void Copy<T>(T t1, out T t2) and verify same behavior. #Resolved

Refers to: src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs:8555 in 46c71ef. [](commit_id = 46c71ef, deletion_comment = False)

jcouv

Done with review pass (iteration 8).

jcouv · 2018-08-06T23:53:37Z

docs/features/nullable-reference-types.md

 var z = F2(obliviousString); // List<string~>! or List<string!>! ?
 var w = F3(obliviousString); // List<string~>! or List<string?>! ?
 ```
+A warning is reported for accessing variables of type T, where T is an unconstrained type parameter.


accessing [](start = 26, length = 9)

nit: dereferencing.

jcouv

LGTM Thanks! (iteration 10)

333fred added 2 commits July 30, 2018 17:41

Fix msbuild langver test

002ff50

Correctly handle unconstrained type parameters in the NullableWalker

f3a36b9

333fred requested review from a team, cston and jcouv July 31, 2018 02:09

333fred requested a review from a team as a code owner July 31, 2018 02:09

cston reviewed Jul 31, 2018

View reviewed changes

Address PR feedback

5626b84

cston reviewed Jul 31, 2018

View reviewed changes

cston reviewed Aug 1, 2018

View reviewed changes

Address PR feedback

8ff9bbd

cston reviewed Aug 1, 2018

View reviewed changes

cston mentioned this pull request Aug 1, 2018

[Work items] Nullable reference types #22152

Closed

Added some tests and adjusted parameter name.

524c5ec

cston reviewed Aug 1, 2018

View reviewed changes

cston approved these changes Aug 1, 2018

View reviewed changes

Add back missing warn comments.

5117748

jcouv reviewed Aug 3, 2018

View reviewed changes

333fred added 2 commits August 6, 2018 10:44

Addressed pr feedback.

46c71ef

jcouv reviewed Aug 6, 2018

View reviewed changes

cston reviewed Aug 6, 2018

View reviewed changes

jcouv reviewed Aug 6, 2018

View reviewed changes

cston reviewed Aug 6, 2018

View reviewed changes

cston approved these changes Aug 6, 2018

View reviewed changes

jcouv reviewed Aug 6, 2018

View reviewed changes

333fred added 2 commits August 6, 2018 16:45

Addressed pr feedback.

398bd4b

Fix test type.

8b6189d

jcouv reviewed Aug 6, 2018

View reviewed changes

jcouv approved these changes Aug 6, 2018

View reviewed changes

Fix test failure and update spec.

c9f8f50

333fred merged commit 109bb19 into dotnet:features/NullableReferenceTypes Aug 7, 2018

333fred deleted the unconstrained-type-parameter-nullability branch August 7, 2018 00:47

		@@ -36173,60 +36156,74 @@ public void UnconstrainedTypeParameter_Return_03()
		static U F20<T, U>(T t) where U : T, new() => (U)t;
		}";

Conversation

333fred commented Jul 31, 2018

Uh oh!

cston Jul 31, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Jul 31, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Jul 31, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Jul 31, 2018 • edited by jcouv Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston commented Jul 31, 2018 • edited by jcouv Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

cston Jul 31, 2018 • edited by jcouv Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Jul 31, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Aug 1, 2018

Choose a reason for hiding this comment

Uh oh!

cston commented Jul 31, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

333fred commented Jul 31, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

cston Jul 31, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

333fred Aug 1, 2018

Choose a reason for hiding this comment

Uh oh!

cston Aug 1, 2018

Choose a reason for hiding this comment

Uh oh!

333fred Aug 1, 2018

Choose a reason for hiding this comment

Uh oh!

cston Jul 31, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Aug 1, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

333fred commented Aug 1, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

cston Aug 1, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Aug 1, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Aug 1, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Aug 1, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Aug 1, 2018 • edited by 333fred Loading Uh oh! There was an error while loading. Please reload this page.

cston Jul 31, 2018 •

edited by 333fred

Loading

cston Jul 31, 2018 •

edited by 333fred

Loading

cston Jul 31, 2018 •

edited by 333fred

Loading

cston Jul 31, 2018 •

edited by jcouv

Loading

cston commented Jul 31, 2018 •

edited by jcouv

Loading

cston Jul 31, 2018 •

edited by jcouv

Loading

cston Jul 31, 2018 •

edited by 333fred

Loading

cston commented Jul 31, 2018 •

edited by 333fred

Loading

333fred commented Jul 31, 2018 •

edited

Loading

cston Jul 31, 2018 •

edited by 333fred

Loading

cston Jul 31, 2018 •

edited by 333fred

Loading

cston Aug 1, 2018 •

edited by 333fred

Loading

333fred commented Aug 1, 2018 •

edited

Loading

cston Aug 1, 2018 •

edited by 333fred

Loading

cston Aug 1, 2018 •

edited by 333fred

Loading

cston Aug 1, 2018 •

edited by 333fred

Loading

cston Aug 1, 2018 •

edited by 333fred

Loading

cston Aug 1, 2018 •

edited by 333fred

Loading

jcouv Aug 3, 2018 •

edited

Loading

jcouv Aug 3, 2018 •

edited by 333fred

Loading

jcouv Aug 5, 2018 •

edited by 333fred

Loading

jcouv Aug 3, 2018 •

edited

Loading

jcouv Aug 3, 2018 •

edited

Loading

jcouv commented Aug 3, 2018 •

edited

Loading

jcouv commented Aug 3, 2018 •

edited

Loading

jcouv Aug 3, 2018 •

edited

Loading

jcouv Aug 3, 2018 •

edited by 333fred

Loading

jcouv Aug 3, 2018 •

edited by 333fred

Loading

jcouv commented Aug 3, 2018 •

edited by 333fred

Loading

jcouv commented Aug 3, 2018 •

edited

Loading

jcouv Aug 6, 2018 •

edited by 333fred

Loading

cston Aug 6, 2018 •

edited by 333fred

Loading