Infer delegate type for method groups and anonymous functions by cston · Pull Request #52448 · dotnet/roslyn

cston · 2021-04-06T22:35:07Z

Infer delegate type for method groups and anonymous functions.

The inferred delegate type is used to allow implicit conversion of method groups and lambdas to System.Delegate.

static void Main(string[] args)
{
    System.Delegate d;
    d = Main;              // System.Action<System.String[]>
    d = () => args.Length; // System.Func<System.Int32>
}

The inferred delegate type is ignored in other scenarios currently, so method groups and lambdas cannot be used as var initializers, nor implicitly converted to object with this change.

Proposal: lambda-improvements.md#natural-delegate-type
Test plan: #52192

cston · 2021-04-08T05:13:15Z

cc @halter73

jcouv · 2021-04-13T20:16:47Z

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

+                // (9,13): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
                //         if (a.E! != null) // 2
-                Diagnostic(ErrorCode.ERR_BadBinaryOps, "a.E! != null").WithArguments("!=", "method group", "<null>").WithLocation(9, 13),
+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "a.E").WithArguments("inferred delegate type").WithLocation(9, 13),


Please test with LangVer=preview (I assume the delegate is considered not-null, so warnings on lines 2 and 9 go away) #Closed

DelegateTypeTests contains several specific tests for language version. For other tests, I chose to either use /langversion:9 or /langversion:preview but not both since both seemed unnecessary. Let me know if you'd prefer the other tests to use /langversion:preview.

jcouv · 2021-04-13T20:17:15Z

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

        }

-        [Fact]
+        [ConditionalFact(typeof(IsRelease))]


What motivated the change? #Closed

What motivated the change?

There is additional validation of lambdas in Binder.CreateAnonymousFunctionConversion(), and similar validation of method groups in Binder.CreateMethodGroupConversion(), that made these tests unnecessarily expensive in DEBUG. #Closed

Consider leaving a comment explaining why we skip (it's just slow)

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

jcouv · 2021-04-13T20:17:20Z

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

+    {
+        object o = () => { };
+        System.ICloneable c = () => { };
+        System.Delegate d = () => { };


Should we also test MulticastDelegate per LDM discussion yesterday? #Closed

PROTOTYPE for object and ICloneable (those should work too, right?)

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

Added failing test for System.MulticastDelegate and added items to the test plan for each (rather than adding PROTOTYPE comments). #Closed

jcouv · 2021-04-13T20:17:24Z

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

            var comp = CreateCompilation(source);
            comp.VerifyDiagnostics(
-                // (6,30): error CS0019: Operator '==' cannot be applied to operands of type '<null>' and 'lambda expression'
+                // (6,65): error CS8652: The feature 'inferred delegate type' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.


Could you also verify diagnostics with LangVer=preview? (also consider doing the same in TestTypelessTupleAndTupleOfDefaults above, and TestWithTypelessTuple below) #Closed

jcouv · 2021-04-13T20:21:31Z

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

+            yield return getData("static object F(int _1, object _2, int _3, object _4, int _5, object _6, int _7, object _8, int _9, object _10, int _11, object _12, int _13, object _14, int _15, object _16, int _17) => null;", "F", null, null);
+            yield return getData("T F<T>() => default;", "(new Program()).F<int>", "System.Func<System.Int32>", "Func`1");
+
+            static object?[] getData(string methodDeclaration, string methodGroupExpression, string? expectedType, string? expectedName) =>


It looks like methodGroupExpression is always "F". Consider removing that parameter and hard-coding in tests #Closed

The method declaration and method group are related, and at the moment, the test and the test data are mostly independent. #Closed

jcouv · 2021-04-13T22:51:29Z

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

-            var delegateType = type.GetDelegateType();
+            var delegateType = (type.SpecialType == SpecialType.System_Delegate) ?
+                // PROTOTYPE: We're resolving the method group multiple times in the code path for a single conversion.
+                _binder.GetMethodGroupDelegateType(methodGroup, diagnostics).Item1 :


Consider using tuple names.
Do we have a caller of GetMethodGroupDelegateType that consumes Item2? #Closed

Do we have a caller of GetMethodGroupDelegateType that consumes Item2?

Good catch, that value is unused. #Closed

jcouv · 2021-04-14T00:26:57Z

src/Compilers/CSharp/Portable/Errors/MessageID.cs

                // C# preview features.
                case MessageID.IDS_FeatureMixedDeclarationsAndExpressionsInDeconstruction:
                case MessageID.IDS_FeatureLambdaAttributes:
+                case MessageID.IDS_FeatureInferredDelegateType:


// semantic check #Closed

jcouv · 2021-04-14T00:37:29Z

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

+                foreach (var scope in new ExtensionMethodScopes(this))
+                {
+                    var methodGroup = MethodGroup.GetInstance();
+                    try


Do we need the try/finally? For comparison, BindExtensionMethod does without. #Closed

jcouv · 2021-04-14T00:42:47Z

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

+        d = t.F1<int>;
+        d = t.F1<T>;
+        d = t.F2<T, object>;
+        d = t.F2<object, T>;


Do we have a test similar to this (instance or extension method with type parameters converted to Delegate) but where type arguments are not provided on the method group? I assume then the method group will just be empty, is that right? #Closed

What was the resolution?

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

What was the resolution?

I've updated this test to include method groups without type arguments. It'll be in the next commit. #Closed

jcouv · 2021-04-14T00:45:57Z

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

+                return null;
+            }
+            var method = node.Methods.SingleOrDefault();
+            if (node.SearchExtensionMethods)


~~Should we even look at extension methods if we've found exactly one instance method already?~~

It looks like this was discussed in LDM (I must have zoned out). From the spec:

Requiring a method group to contain a single method means that adding an overload (including an extension method overload) for a method that previously had no overloads is a breaking change if the original method was used as a method group with inferred type. #Closed

jcouv · 2021-04-14T00:57:55Z

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

+    void F()
+    {
+        Delegate d1 = F1;
+        Delegate d2 = this.F2;


It looks like base has special rules for binding method groups. Consider adding a test:
See BindInstanceMemberAccess (line 6290)
var searchExtensionMethodsIfNecessary = !leftIsBaseReference; #Closed

Consider also testing with type as LHS: Delegate d3 = Program3.StaticMethod and Delegate d4 = Program4<int>.StaticMethod
Also test with a dynamic receiver (error)

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

Added ExtensionMethods_05() for base with an extension method; added tests for static methods with explicit type to GetMethodGroupData(); added DynamicReceiver() for dynamic test. #Closed

jcouv · 2021-04-14T01:27:20Z

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

        {
            // Must be a bona fide delegate type, not an expression tree type.
-            if (!destination.IsDelegateType())
+            if (!(destination.IsDelegateType() || destination.SpecialType == SpecialType.System_Delegate))


Should we also allow destination to be object, or ICloneable, or MulticastDelegate here? #Closed

Should we also allow destination to be object, or ICloneable, or MulticastDelegate here?

Perhaps. Let's address later when handling those cases. #Closed

jcouv · 2021-04-14T01:32:14Z

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

-                constantValueOpt: ConstantValue.NotAvailable,
-                type: destination)
-            { WasCompilerGenerated = source.WasCompilerGenerated };
+            if (destination.SpecialType == SpecialType.System_Delegate || destination.IsNonGenericExpressionType())


destination.SpecialType == SpecialType.System_Delegate

Same here (object, ICloneable, etc) and below in createAnonymousFunctionConversion, CreateMethodGroupConversion, MethodGroupConversionHasErrors and other places in this PR. Consider extracting this check to a helper method, so that we don't forget to fix some places when adding support for those other types #Closed

Let's address later when addressing implicit conversions to those base and interface types. #Closed

jcouv · 2021-04-14T01:34:56Z

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

            var conversion = (resolution.IsEmpty || resolution.HasAnyErrors) ?
                Conversion.NoConversion :
-                ToConversion(resolution.OverloadResolutionResult, resolution.MethodGroup, ((NamedTypeSymbol)destination).DelegateInvokeMethod.ParameterCount);
+                ToConversion(resolution.OverloadResolutionResult, resolution.MethodGroup, (destination.SpecialType == SpecialType.System_Delegate ? methodSymbol : ((NamedTypeSymbol)destination).DelegateInvokeMethod).ParameterCount);


destination.SpecialType == SpecialType.System_Delegate ? methodSymbol : ((NamedTypeSymbol)destination).DelegateInvokeMethod

Could we unconditionally use methodSymbol here? #Closed

jcouv · 2021-04-14T01:39:44Z

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

+
+            return expr;
+
+            BoundConversion createAnonymousFunctionConversion(SyntaxNode syntax, UnboundLambda unboundLambda, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics)


static? #Closed

The local function uses this.Compilation. #Closed

jcouv · 2021-04-14T01:45:27Z

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

+                    return true;
+                }
+                if (type.Arity == 1 &&
+                    type.MangleName)


nit: this is existing logic, but isn't it redundant with the Arity check? #Closed

this is existing logic, but isn't it redundant with the Arity check?

This check will ensure we don't match to a generic type named Expression without the trailing `1, although that scenario is unlikely. Since this is an existing check, I'll leave it as is. #Closed

jcouv · 2021-04-14T03:39:26Z

src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs

            else
            {
-                lambdaSymbol = CreateLambdaSymbol(Binder.ContainingMemberOrLambda, returnType, cacheKey.ParameterTypes, cacheKey.ParameterRefKinds, refKind);
+                lambdaSymbol = CreateLambdaSymbol(Binder.ContainingMemberOrLambda!, returnType, cacheKey.ParameterTypes, cacheKey.ParameterRefKinds, refKind);


Binder.ContainingMemberOrLambda!

nit: should be an assertion. Also in BindWithParameterAndReturnType below #Closed

Added an assertion to UnboundLambda..ctor(). #Closed

jcouv · 2021-04-14T03:47:54Z

src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs

            return true;
        }

+        private BoundLambda ReallyBindNaturalType(TypeSymbol expressionType)


nit: consider calling the parameter "delegateType" to match caller and other similar method #Closed

In this case, the type is not a (strongly-typed) delegate type though. It is either System.Delegate or System.Linq.Expressions.Expression. I realize the naming is inconsistent since callers refer to this as "delegateType" but I was reluctant to change the callers. The current names were a compromise although not ideal. #Closed

jcouv · 2021-04-14T03:48:59Z

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

+}");
+        }
+    }
+}


Some test ideas:

the spec calls out behavior when the lambda or method group involves a modreq or modopt, but I couldn't find tests for that. ("modopt() or modreq() in the method group signature are ignored in the corresponding delegate type.")

make Action, Func, or Delegate missing

have we covered this section of the spec: "if [...] any of the parameter types or return are not valid type arguments"?

I'm not sure how to track this: we should remember to test delegate type inference once we support explicit return types. (I don't expect any problem though)

You already have tests for Type and Converted types of the lambda and method group. We should do the same but also verifying inferred nullability.

var and invocation sections of the spec are intentionally out of scope for this PR, is that correct?

Do we have some tests that verify the emitted delegate type (as opposed to just the semantic model)? #Closed

Thanks for the suggestions:

Added tests for modopt and modreq.

Added tests for missing System.Action and System.Func; added missing System.Delegate to the test plan.

Added test for parameter types and return type that are not valid type arguments.

No change.

Added nullability to test plan.

Correct, var and directly invoking a lambda expression are out of scope. Included in test plan.

A number of tests report the delegate type from the compiled executable. #Closed

jcouv · 2021-04-14T03:49:47Z

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

+                comp.VerifyDiagnostics(
+                // (6,20): error CS0030: Cannot convert type 'method' to 'Delegate'
+                //         object o = (System.Delegate)F;
+                Diagnostic(ErrorCode.ERR_NoExplicitConv, "(System.Delegate)F").WithArguments("method", "System.Delegate").WithLocation(6, 20));


nit: indent #Closed

jcouv · 2021-04-14T03:52:14Z

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

+}";
+            var comp = CreateCompilation(source, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics();
+        }


If we don't have tests for that already, can we check the natural type (on semantic model) in extension scenario? #Closed

Tested type from the semantic model and at runtime. (Note, the semantic model currently does not expose the natural type. I've added an item to the test plan to handle that.) #Closed

333fred · 2021-04-22T21:35:16Z

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

+            else
+            {
+                CompileAndVerify(comp, expectedOutput: expectedType);
+            }


Consider asserting TypeInfo here as well. #Resolved

Same here.

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

333fred · 2021-04-22T21:37:21Z

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

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


Consider asserting TypeInfo here as well. #Resolved

Same here.

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

jcouv · 2021-04-22T21:49:44Z

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

+                        if (m.IsStatic) continue;
+                        break;
+                }
+                if (!updateCandidate(ref method, m))


nit: the name and return value of this local function make this odd. Consider "if (!isCandidateUnique(ref candidate, m))`? #Closed

333fred · 2021-04-22T21:55:37Z

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

+{{
+    void M()
+    {{
+        System.Delegate d = {methodGroupExpression};


methodGroupExpression

Consider using GetSymbolInfo to validate what extension method this is binding to. #Resolved

Added runtime validation.

GetSymbolInfo() does not return the resolved extension method currently. I've added a PROTOTYPE comment for now.

333fred · 2021-04-22T21:59:17Z

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

+{{
+    void M()
+    {{
+        System.Delegate d = {methodGroupExpression};


methodGroupExpression

Same here: consider asserting what method this is actually binding to. #Resolved

333fred · 2021-04-22T22:18:48Z

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

+            comp.VerifyDiagnostics(
+                // (14,15): error CS8915: The delegate type could not be inferred.
+                //         d = p.F2;
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "F2").WithLocation(14, 15));


This isn't making sense to me: why can't this be inferred to Action? #Closed

why can't this be inferred to Action?

Because there are two overloads with distinct signatures: Program.F2(int x) and E.F2(this object x). #Closed

Ah, ok, thanks. I missed that one.

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

jcouv · 2021-04-22T22:28:08Z

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

+                        if (!m.IsStatic) continue;
+                        break;
+                    case { WasCompilerGenerated: false }:
+                        if (m.IsStatic) continue;


I need help understanding this (why distinguish on whether the receiver is compiler-generated or not). Let's chat later this afternoon. #Closed

Changed to use explicit case BoundThisReference { ... }: for clarity based on our conversation. #Closed

333fred · 2021-04-22T23:13:34Z

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

+    }
+}";
+
+            var expectedOutput = @"M(Action<string> a)";


This should end up being M<T>(T t) in a follow up, right? #Closed

Yes, this test and the following test will change. #Closed

333fred · 2021-04-22T23:23:53Z

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

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


I'm not sure what these are actually testing? #Closed

Added comments. #Closed

333fred · 2021-04-22T23:27:55Z

Done review pass (commit 15)

jcouv · 2021-04-23T05:40:54Z

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

+{
+  .method public hidebysig specialname rtspecialname instance void .ctor() cil managed { ret }
+}";
+            var refA = CompileIL(sourceA, prependDefaultHeader: false, autoInherit: false);


nit: Is it necessary to use IL to test those types are missing? (also in test below). I'd have though MakeMemberMissing or a C# implementation could do.
It would be good to also test Expression e = () => {}; with missing Expression1` #Closed

The IL is simple enough for these missing types so that seemed easiest.

Added a test for Expression<TDelegate>.

jcouv · 2021-04-23T05:42:02Z

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

+
+            var comp = CreateEmptyCompilation(sourceB, new[] { refA }, parseOptions: TestOptions.RegularPreview);
+            comp.VerifyDiagnostics(
+                // (9,13): error CS0648: 'Action<T>' is a type not supported by the language


Seems like we're getting a duplicate error. Is that expected? #Closed

Yes, we're currently calling GetMethodGroupDelegateType() twice in the code path that generates the conversion. There are PROTOTYPE comments to avoid the duplicate calls. #Closed

jcouv · 2021-04-23T05:53:16Z

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

+                Diagnostic(ErrorCode.ERR_FeatureInPreview, "() => { }").WithArguments("inferred delegate type").WithLocation(8, 13));
+
+            CompileAndVerify(source, parseOptions: TestOptions.RegularPreview, expectedOutput:
+@"C.M


It would be good to comment on behavior change. Should document the break in compiler doc. #Closed

The behavior has not changed yet. I will update the breaking change document at the same time. #Closed

Copy&pasting this test into sharplab I get `E.M" in output.

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

You're right, thanks. I've added a comment and updated the breaking change document. #Closed

jcouv

Done with review pass (iteration 16)

cston · 2021-04-23T21:07:32Z

@333fred, @jcouv, all feedback has been addressed, thanks.

jcouv · 2021-04-23T22:51:44Z

        // Breaking change from C#9 which binds to E.M.

Is this the only overload resolution test illustrates a breaking change?

In reply to: 825981242

Refers to: src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs:1832 in ec93572. [](commit_id = ec93572, deletion_comment = False)

jcouv · 2021-04-23T22:55:18Z

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs

                return LambdaConversionResult.ExpressionTreeFromAnonymousMethod;
            }

+            if (delegateType is null)


nit: Consider if (type.Arity == 0) ... if that is more directly what is intended, and assert that delegateType is not null otherwise. #ByDesign

I'll leave as is, since delegateType here means the type argument to Expression<TDelegate> which is null for non-generic Expression.

cston · 2021-04-23T22:56:06Z

        // Breaking change from C#9 which binds to E.M.

Sure

In reply to: 825982476

Refers to: src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs:1832 in ec93572. [](commit_id = ec93572, deletion_comment = False)

jcouv

LGTM Thanks (iteration 17) with a question and a nit to consider.

jcouv · 2021-04-23T23:08:20Z

        // Breaking change from C#9 which binds to E.M.

Sure

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

Refers to: src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs:1832 in ec93572. [](commit_id = ec93572, deletion_comment = False)

333fred

LGTM (commit 17). A couple of test followup comments left, but they should be quick to address.

jcouv · 2021-04-24T02:40:46Z

        // https://github.com/dotnet/roslyn/issues/52870: GetSymbolInfo() should return resolved method from method group.

It looks like you added tests for GetSymbolInfo on method groups, but not lambdas. Could you show what's the current behavior and file an issue if needed?

Refers to: src/Compilers/CSharp/Test/Semantic/Semantics/DelegateTypeTests.cs:766 in b147208. [](commit_id = b147208, deletion_comment = False)

davidfowl · 2021-04-24T09:10:06Z

🔥🔥🔥

ghost added the Area-Compilers label Apr 6, 2021

cston force-pushed the delegate-type branch 3 times, most recently from 3338080 to 87f22bc Compare April 7, 2021 23:29

cston marked this pull request as ready for review April 8, 2021 02:49

cston requested a review from a team as a code owner April 8, 2021 02:49

Infer delegate type for method groups and anonymous functions

02c64c2

cston force-pushed the delegate-type branch from d6812a7 to 02c64c2 Compare April 8, 2021 05:03

jcouv reviewed Apr 13, 2021

View reviewed changes

jcouv reviewed Apr 14, 2021

View reviewed changes

333fred reviewed Apr 22, 2021

View reviewed changes

jcouv reviewed Apr 22, 2021

View reviewed changes

333fred reviewed Apr 22, 2021

View reviewed changes

jcouv reviewed Apr 22, 2021

View reviewed changes

333fred reviewed Apr 22, 2021

View reviewed changes

jcouv reviewed Apr 23, 2021

View reviewed changes

PR feedback

2184322

jcouv reviewed Apr 23, 2021

View reviewed changes

jcouv approved these changes Apr 23, 2021

View reviewed changes

PR feedback

ec93572

jcouv reviewed Apr 23, 2021

View reviewed changes

jcouv approved these changes Apr 23, 2021

View reviewed changes

333fred approved these changes Apr 24, 2021

View reviewed changes

PR feedback

b147208

cston merged commit db80551 into dotnet:features/lambdas Apr 24, 2021

cston deleted the delegate-type branch April 24, 2021 04:26

cston mentioned this pull request May 6, 2021

Infer delegate types with -langversion:preview only #53241

Merged

jcouv added the Feature - Lambda Improvements label May 7, 2021


		return expr;

		BoundConversion createAnonymousFunctionConversion(SyntaxNode syntax, UnboundLambda unboundLambda, Conversion conversion, bool isCast, ConversionGroup? conversionGroup, TypeSymbol destination, BindingDiagnosticBag diagnostics)

Conversation

cston commented Apr 6, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

cston commented Apr 8, 2021

Uh oh!

jcouv Apr 13, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Apr 13, 2021

Choose a reason for hiding this comment

Uh oh!

jcouv Apr 13, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Apr 13, 2021 • 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!

jcouv Apr 14, 2021

Choose a reason for hiding this comment

Uh oh!

jcouv Apr 13, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jcouv Apr 14, 2021

Choose a reason for hiding this comment

Uh oh!

cston Apr 14, 2021 • 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!

jcouv Apr 13, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jcouv Apr 13, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Apr 13, 2021 • 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!

jcouv Apr 13, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cston Apr 13, 2021 • 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!

jcouv Apr 14, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jcouv Apr 14, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jcouv Apr 14, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jcouv Apr 14, 2021

Choose a reason for hiding this comment

Uh oh!

cston Apr 14, 2021 • 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!

jcouv Apr 14, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jcouv Apr 14, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

cston commented Apr 6, 2021 •

edited

Loading

jcouv Apr 13, 2021 •

edited

Loading

jcouv Apr 13, 2021 •

edited

Loading

cston Apr 13, 2021 •

edited by jcouv

Loading

jcouv Apr 13, 2021 •

edited

Loading

cston Apr 14, 2021 •

edited by jcouv

Loading

jcouv Apr 13, 2021 •

edited

Loading

jcouv Apr 13, 2021 •

edited

Loading

cston Apr 13, 2021 •

edited by jcouv

Loading

jcouv Apr 13, 2021 •

edited

Loading

cston Apr 13, 2021 •

edited by jcouv

Loading

jcouv Apr 14, 2021 •

edited

Loading

jcouv Apr 14, 2021 •

edited

Loading

jcouv Apr 14, 2021 •

edited

Loading

cston Apr 14, 2021 •

edited by jcouv

Loading

jcouv Apr 14, 2021 •

edited

Loading

jcouv Apr 14, 2021 •

edited

Loading

jcouv Apr 14, 2021 •

edited

Loading

cston Apr 14, 2021 •

edited by jcouv

Loading

jcouv Apr 14, 2021 •

edited

Loading

cston Apr 14, 2021 •

edited by jcouv

Loading

jcouv Apr 14, 2021 •

edited

Loading

cston Apr 14, 2021 •

edited by jcouv

Loading

jcouv Apr 14, 2021 •

edited

Loading

jcouv Apr 14, 2021 •

edited

Loading

cston Apr 14, 2021 •

edited by jcouv

Loading

jcouv Apr 14, 2021 •

edited

Loading

cston Apr 14, 2021 •

edited by jcouv

Loading

jcouv Apr 14, 2021 •

edited by 333fred

Loading

cston Apr 14, 2021 •

edited by 333fred

Loading

jcouv Apr 14, 2021 •

edited

Loading

cston Apr 14, 2021 •

edited by jcouv

Loading

jcouv Apr 14, 2021 •

edited

Loading