Initial support for "Simple Programs" feature. #41706

AlekseyTs · 2020-02-14T20:39:01Z

This is a punch through to support simple single file scenarios.
Related to #41704.

This is a punch through to support simple single file scenarios. Related to dotnet#41704.

…mplePrograms_01

CyrusNajmabadi · 2020-02-14T20:46:23Z

Would you like feedback on the draft? Or would you prefer that wait until a later point? #Closed

AlekseyTs · 2020-02-14T20:53:25Z

Would you like feedback on the draft?

We use Draft PRs for personal review. #Closed

CyrusNajmabadi · 2020-02-14T21:11:39Z

We use Draft PRs for personal review.

Ok sounds good. The reason i brought it up was because there are other PRs going through that affect statement parsing (both in Master and in features/local-function-attributes), so i wanted to try to help out to make that as smooth as possible.

Will provide more info once you're ready for that. Thanks! #Closed

AlekseyTs · 2020-02-14T22:02:52Z

@dotnet/roslyn-compiler Please review.

CyrusNajmabadi · 2020-02-14T22:05:32Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

+            if (!IsScript)
+            {
+                IsInAsync = true;
+            }


can this logic be commented? it's not clear ot me why a top level using forces an async parsing context. #Closed

it's not clear ot me why a top level using forces an async parsing context.

Simple Program is implicitly async. I guess the speclet doesn't say that explicitly, but it can be inferred from the first code snippet in the https://github.com/dotnet/csharplang/blob/master/proposals/Simple-programs.md#semantics section. I'll clarify that.

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

Simple Program is implicitly async.

Ah, good to know.

I'll clarify that.

👍 #Closed

CyrusNajmabadi · 2020-02-14T22:13:52Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

            if (this.IsIncrementalAndFactoryContextMatches)
            {
-                if (CanReuseMemberDeclaration(CurrentNodeKind))
+                if (CanReuseMemberDeclaration(CurrentNodeKind, isGlobalNonScript: isGlobal && !IsScript))


feels a little weird to need to pass a global-parsing-state-flag into the nested helper. i.e. it feels cleaner to me that CanReuseMemberDeclaration just reference IsScript within it. #Resolved

it feels cleaner to me that CanReuseMemberDeclaration just reference IsScript within it.

Could you please elaborate? IsScript simply indicates what kind parse options we are using, it says nothing about the context.

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

so it feels like you could just call CanReuseMemberDeclaration(CurrentNodeKind, isGlobal). Then, inside CanReuseMemberDeclaration if you care if it is global and non-script you can just have a local in there like var isGlobalNonScript = isGlobal && !IsScript;.

In other words, It doesn't feel like teh caller has to provide this information. But maybe i'm missing something here. #Resolved

Another way of putting it: contextual information should pass downward. Data that is the same for the entire doc (like IsScript) doesn't need to pass down, it can just be retrieved when needed. #Resolved

CyrusNajmabadi · 2020-02-14T22:15:57Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

                        if (IsFieldDeclaration(isEvent: false))
                        {
-                            if (acceptStatement)
+                            if (isGlobal && !haveAttributes && !(haveModifiers && IsScript))


fwiw, these conditions are pretty hard to both grok and to determine correctness around. i don't really get a sense for why this is the appropriate rules for this sort of situation. #Resolved

fwiw, these conditions are pretty hard to both grok and to determine correctness around. i don't really get a sense for why this is the appropriate rules for this sort of situation.

The conditions are mostly preserving original logic. acceptStatement was false if there were attributes or modifiers. We allow modifiers for non-script case though

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

CyrusNajmabadi · 2020-02-14T22:29:13Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

+                    //                            inGlobalNonScript context, but that would require extending NodeFlags enum, which
+                    //                            already uses all bits available in a byte.
+                    //                            At the same time that would allow us to reuse top-level statements (GlobalStatementSyntax) as well.
+                    return !isGlobalNonScript;


i.e. the .IsScript check can move here. #Resolved

gafter · 2020-02-17T21:46:16Z

I am holding off on reviewing this pending LDM review of the draft specification. I expect this prototype may be helpful in gathering some experience, but I believe that the draft specification is unlikely to be approved by the LDM in its current form, and changes are likely to affect implementation decisions in the prototype. #Resolved

jaredpar · 2020-02-17T23:22:05Z

@gafter

We're not going to block compiler development on the LDM approval process. The spec here is a work in progress that @MadsTorgersen is in sync with. As the LDM process evolves so will the implementation and the draft of the proposal.
#Resolved

gafter · 2020-02-18T00:43:17Z

@jaredpar I did not intend to block anything.

I expect this prototype may be helpful in gathering some experience with the proposed feature leading up to an LDM review of the proposed specification. I am not confident that a code review would be a good use of my time as I believe the specification is likely to change significantly or be withdrawn. I will be happy to explain why if/when we review the proposal in the LDM. There are other features that have been reviewed and are unimplemented for C# 9.0. But by all means, development can continue on this prototype if you believe that is the best way to move forward on LDM-approved features, and I hope it leads to useful insight for LDM review. #Resolved

AlekseyTs · 2020-02-18T17:45:28Z

@dotnet/roslyn-compiler Please review.

AlekseyTs · 2020-02-19T17:40:42Z

@dotnet/roslyn-compiler Please review.

RikkiGibson · 2020-02-19T19:29:19Z

src/Compilers/CSharp/Portable/Binder/BinderFactory.BinderFactoryVisitor.cs

                {
                    Binder outer = VisitCore(parent.Parent); // a binder for the body of the type enclosing this type
-                    var container = ((NamespaceOrTypeSymbol)outer.ContainingMemberOrLambda).GetSourceTypeMember(parent.Identifier.ValueText, 0, SyntaxKind.EnumDeclaration, parent);
+                    var container = ((NamespaceOrTypeSymbol)ContainingMemberOrLambdaSkippingSimpleProgramEntryPoint(outer)).GetSourceTypeMember(parent.Identifier.ValueText, 0, SyntaxKind.EnumDeclaration, parent);


Consider splitting this statement and the similar change above into multiple lines #Closed

Consider splitting this statement and the similar change above into multiple lines

In the next change (will go in as a separate PR) I am adjusting what binder we create in VisitCompilationUnit method, making the use of ContainingMemberOrLambdaSkippingSimpleProgramEntryPoint unnecessary. I am removing that helper and restoring call-sites to the state prior to this change.

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

RikkiGibson · 2020-02-19T20:42:48Z

(self-requesting so the PR will show up in GitHub Pull Requests in VS Code) #Resolved

RikkiGibson

I have some comments but I'm still working on reviewing this PR. I haven't fully reviewed LanguageParser.cs or the tests yet.

RikkiGibson · 2020-02-19T20:49:08Z

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

+                if ((options & LookupOptions.LabelsOnly) != 0 && scope.IsLastBinderWithinMember())
+                {
+                    // Labels declared outside of a member are not visible inside.
+                    break;


Can we only hit this line when a member references a label declared at the top level? #Resolved

Can we only hit this line when a member references a label declared at the top level?

We hit this line for every label reference that cannot be resolved within a member body.

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

RikkiGibson · 2020-02-19T21:22:44Z

src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs

+                        }
+
+                        RoslynDebug.Assert(simpleProgramEntryPointSymbol is object);
+                        entryPointCandidates.Clear();


Do we plan on using the entry point candidates we found at this point to give diagnostics in a future PR? #Resolved

Do we plan on using the entry point candidates we found at this point to give diagnostics in a future PR?

What diagnostics do you have in mind? We already reported ErrorCode.WRN_MainIgnored above. Is this not sufficient?

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

RikkiGibson · 2020-02-20T01:10:11Z

src/Compilers/CSharp/Portable/Lowering/Instrumentation/DynamicAnalysisInjector.cs

            // Do not instrument implicitly-declared methods, except for constructors.
            // Instrument implicit constructors in order to instrument member initializers.
-            if (method.IsImplicitlyDeclared && !method.IsImplicitConstructor)
+            if (method.IsImplicitlyDeclared && !method.IsImplicitConstructor && !(method is SynthesizedSimpleProgramEntryPointSymbol))


Do we expect to be able to instrument simple programs? How is that done? #Closed

Do we expect to be able to instrument simple programs?

Why wouldn't we?

How is that done?

As any other method body, I guess.

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

I misread what the check was actually doing here. Chatted offline and the change makes sense to me now.

In reply to: 382160492 [](ancestors = 382160492,381637134)

RikkiGibson · 2020-02-20T01:24:14Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

+                            case SyntaxKind.UnsafeKeyword:
+                                if (this.PeekToken(1).Kind == SyntaxKind.OpenBraceToken)
+                                {
+                                    return CheckFeatureAvailability(_syntaxFactory.GlobalStatement(ParseUnsafeStatement()));


Consider naming this method something like "CheckSimpleProgramsFeatureAvailability" #Pending

RikkiGibson · 2020-02-20T01:39:05Z

src/Compilers/CSharp/Portable/Parser/SyntaxParser.cs

        /// It should be used as a guardrail, not as a crutch, so it asserts if no progress was made.
        /// </summary>
-        protected bool IsMakingProgress(ref int lastTokenPosition)
+        protected bool IsMakingProgress(ref int lastTokenPosition, bool assertIfFalse = true)


Will this change be reverted before merging to master? #Resolved

Will this change be reverted before merging to master?

I do not have plans to do that at the moment. This doesn't change behavior for any existing code.

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

RikkiGibson · 2020-02-20T01:44:31Z

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

+    /// <summary>
+    /// Represents implicitly declared type for a Simple Program feature.
+    /// </summary>
+    internal sealed class SimpleProgramNamedTypeSymbol : SourceMemberContainerTypeSymbol


I noticed there is a Synthesized folder here where the SynthesizedSimpleProgramEntryPointSymbol has been placed, should this also go in there? #Closed

I noticed there is a Synthesized folder here where the SynthesizedSimpleProgramEntryPointSymbol has been placed, should this also go in there?

This is where ImplicitNamedTypeSymbol lives, which is another flavor of the same. I decided to keep them close.

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

agocke · 2020-02-21T00:01:45Z

docs/features/SimplePrograms.md

@@ -0,0 +1,22 @@
+Simple Programs


Can we call this "top-level statements"? "Simple programs" is more the goal of the feature, rather than the feature itself. #Resolved

This is the name of the feature.

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

agocke · 2020-02-21T20:38:46Z

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


        internal static CSharpSyntaxNode ExtractReturnTypeSyntax(this MethodSymbol method)
        {
+            if (method is SynthesizedSimpleProgramEntryPointSymbol synthesized)


I wouldn't expect this to work at all. This method is asking for the syntax of the stated return type, but we don't have a stated return type. #Resolved

I wouldn't expect this to work at all. This method is asking for the syntax of the stated return type, but we don't have a stated return type.

We need this method to return reasonable non-null node. To the user it can be surfaced only as an error location. The current implementation is reasonable enough, in my opinion. There is a PROTOTYPE comment to give it another thought later.

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

agocke · 2020-02-21T21:00:12Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

        private int _recursionDepth;
        private TerminatorState _termState; // Resettable
        private bool _isInTry; // Resettable
+        private bool _checkedSimpleProgramsFeatureAvailability; // Resettable


Is this just to prevent reporting an error for each statement? #Resolved

Is this just to prevent reporting an error for each statement?

Yes.

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

agocke · 2020-02-21T21:41:57Z

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

+            return locals?.ToImmutableAndFree() ?? ImmutableArray<LocalFunctionSymbol>.Empty;
+        }
+
+        internal override bool IsLocalFunctionsScopeBinder


=> true? It keeps things closer together, which is easier for me to read. #WontFix

agocke · 2020-02-21T23:03:33Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

+        /// reduce the stack usage during recursive parsing.
+        /// </summary>
+        /// <returns>Returns null if we can't parse anything (even partially).</returns>
        private MemberDeclarationSyntax ParseMemberDeclarationOrStatementCore(SyntaxKind parentKind)


This method should probably mention it's only meant to be used at the top level #Resolved

This method should probably mention it's only meant to be used at the top level

The name is clear enough, I believe, it parses either a member or a statement. That is only valid to do at the top level.

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

I thought we were also parsing in class declarations for error recovery. Is that wrong? #Resolved

I thought we were also parsing in class declarations for error recovery. Is that wrong?

We don't parse statements within a class or a namespace declaration.

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

agocke · 2020-02-21T23:22:09Z

src/Compilers/CSharp/Portable/Binder/BinderFactory.BinderFactoryVisitor.cs


+            private static Symbol ContainingMemberOrLambdaSkippingSimpleProgramEntryPoint(Binder binder)
+            {
+                var containingMemberOrLambda = binder.ContainingMemberOrLambda;


From the above, I guess this sometimes (always?) returns types or namespaces. Why is it called ContainingMemberOrLambda? #Resolved

From the above, I guess this sometimes (always?) returns types or namespaces. Why is it called ContainingMemberOrLambda?

Because some binders return members or lambdas or even local functions. This PR doesn't change this behavior of the API.

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

agocke · 2020-02-21T23:34:39Z

src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs

+
+                        RoslynDebug.Assert(simpleProgramEntryPointSymbol is object);
+                        entryPointCandidates.Clear();
+                        entryPointCandidates.Add(simpleProgramEntryPointSymbol);


It looks like the remaining pieces of this method are validating that the entry point is acceptable, but since we're synthesizing it I presume we already know that. Why not just return the symbol immediately? #Resolved

It looks like the remaining pieces of this method are validating that the entry point is acceptable, but since we're synthesizing it I presume we already know that. Why not just return the symbol immediately?

This is the candidate and I do not mind doing for it what we would do for any other candidate. I believe this is more robust approach than the suggested one because we don't need to worry if any changes below made in the future invalidate the assumption that it is safe to return.

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

RikkiGibson · 2020-02-22T00:30:37Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

+                        {
+                            var saveTerm = _termState;
+                            _termState |= TerminatorState.IsPossibleStatementStartOrStop; // partial statements can abort if a new statement starts
+                            bool wasInAsync = IsInAsync;


Is this method only supposed to be called to parse things contained directly in the compilation unit? I'm wondering if what scenario do we get here and IsInAsync was already 'true'. #Resolved

Is this method only supposed to be called to parse things contained directly in the compilation unit? I'm wondering if what scenario do we get here and IsInAsync was already 'true'.

I prefer to not make any assumptions, this is more robust in the long term.

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

RikkiGibson · 2020-02-22T00:48:04Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

+                var topLevelStatement = ParseLocalDeclarationStatement();
+                IsInAsync = wasInAsync;
+
+                if (topLevelStatement is DeclarationSyntax declaration && IsMakingProgress(ref lastTokenPosition, assertIfFalse: false))


This feels like a strange way to detect whether the statement that was parsed was meaningful. Could we maybe extract out a helper for ParseLocalDeclarationStatement that returns null when it has nothing to consume from the source text, and the ParseLocalDeclarationStatement method can call it and replace with an "empty" LocalDeclarationStatement to preserve behavior for existing callers? #Resolved

This feels like a strange way to detect whether the statement that was parsed was meaningful. Could we maybe extract out a helper for ParseLocalDeclarationStatement that returns null when it has nothing to consume from the source text, and the ParseLocalDeclarationStatement method can call it and replace with an "empty" LocalDeclarationStatement to preserve behavior for existing callers?

I think that would still require checking if we are making any progress, but in a different place. I'd rather keep this logic here, to avoid people calling the wrong helper unintentionally.

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

AlekseyTs · 2020-02-22T00:50:51Z

@agocke I think I responded to all your comments. #Closed

RikkiGibson · 2020-02-22T00:52:05Z

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

+                    Debug.Assert(identifierOrThisOpt != null);
+
+                    // check availability of readonly members feature for indexers, properties and methods
+                    CheckForVersionSpecificModifiers(modifiers, SyntaxKind.ReadOnlyKeyword, MessageID.IDS_FeatureReadOnlyMembers);


It feels odd to potentially issue LangVersion diagnostics for readonly members here since it doesn't seem like such members are ever allowed at the top level. #Resolved

It feels odd to potentially issue LangVersion diagnostics for readonly members here since it doesn't seem like such members are ever allowed at the top level.

The more errors we can report for misplaced declaration, the better, IMHO.

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

agocke · 2020-02-22T01:15:08Z

One question #41706 (comment). LGTM otherwise. #Resolved

RikkiGibson · 2020-02-22T20:01:26Z

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

+            comp = CreateCompilation(text1 + text2, options: TestOptions.DebugExe, parseOptions: DefaultParseOptions);
+            comp.VerifyDiagnostics();
+
+            Assert.Throws<System.ArgumentException>(() => CreateCompilation(new[] { Parse(text1, filename: "text1", DefaultParseOptions),


Why does this throw? Because of inconsistent parse options between syntax trees? #Resolved

Why does this throw? Because of inconsistent parse options between syntax trees?

Yes. This PR doesn't change this behavior.

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

RikkiGibson · 2020-02-23T20:51:24Z

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

+        Test().EndsWith(null); // 3
+        System.Func<string> d = Test; // 4
+        d();
+        _ = nameof(Test); // 5


should there be a // 5 comment here if there is no diagnostic? #Resolved

should there be a // 5 comment here if there is no diagnostic?

Comments are there to easily distinguish lines from each other in the base-line they are not indicating anything else. There is no requirement to have any matching diagnostics. Nevertheless, once the PROTOTYPE comment below is addressed, there will be a diagnostics for this line.

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

RikkiGibson · 2020-02-23T20:51:51Z

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

+            Test().EndsWith(null); // 8
+            var d = new System.Func<string>(Test); // 9
+            d();
+            _ = nameof(Test); // 10


should there be a // 10 comment here if there is no diagnostic? #Resolved

should there be a // 10 comment here if there is no diagnostic?

Same response. Baselines set expectations, not comments in the test snippets.

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

AlekseyTs added 2 commits February 14, 2020 12:30

Initial support for "Simple Programs" feature.

d86cdce

This is a punch through to support simple single file scenarios. Related to dotnet#41704.

Merge remote-tracking branch 'dotnet/features/SimplePrograms' into Si…

11ceb73

…mplePrograms_01

AlekseyTs added the Area-Compilers label Feb 14, 2020

AlekseyTs added the Feature - Simple Programs Top-level statements label Feb 14, 2020

AlekseyTs marked this pull request as ready for review February 14, 2020 22:02

AlekseyTs requested review from a team as code owners February 14, 2020 22:02

CyrusNajmabadi reviewed Feb 14, 2020

View reviewed changes

AlekseyTs added 2 commits February 14, 2020 16:10

Refactorings

9685513

Another refactoring to reduce stack usage in case of recursion.

8bb32c3

RikkiGibson reviewed Feb 19, 2020

View reviewed changes

RikkiGibson self-requested a review February 19, 2020 20:42

RikkiGibson reviewed Feb 20, 2020

View reviewed changes

agocke reviewed Feb 22, 2020

View reviewed changes

RikkiGibson reviewed Feb 22, 2020

View reviewed changes

agocke approved these changes Feb 22, 2020

View reviewed changes

RikkiGibson reviewed Feb 22, 2020

View reviewed changes

RikkiGibson reviewed Feb 23, 2020

View reviewed changes

RikkiGibson approved these changes Feb 24, 2020

View reviewed changes

AlekseyTs merged commit e54c35a into dotnet:features/SimplePrograms Feb 24, 2020

Initial support for "Simple Programs" feature. #41706

Initial support for "Simple Programs" feature. #41706

Uh oh!

Conversation

AlekseyTs commented Feb 14, 2020

Uh oh!

CyrusNajmabadi commented Feb 14, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

AlekseyTs commented Feb 14, 2020 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

CyrusNajmabadi commented Feb 14, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

AlekseyTs commented Feb 14, 2020

Uh oh!

CyrusNajmabadi Feb 14, 2020 • 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!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Feb 14, 2020 • 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!

CyrusNajmabadi Feb 14, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Feb 14, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Feb 14, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Feb 14, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Feb 14, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

gafter commented Feb 17, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

jaredpar commented Feb 17, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

gafter commented Feb 18, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

AlekseyTs commented Feb 18, 2020

Uh oh!

AlekseyTs commented Feb 19, 2020

Uh oh!

RikkiGibson Feb 19, 2020 • 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!

Choose a reason for hiding this comment

Uh oh!

RikkiGibson commented Feb 19, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

RikkiGibson left a comment

Choose a reason for hiding this comment

Uh oh!

RikkiGibson Feb 19, 2020 • edited by AlekseyTs Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi commented Feb 14, 2020 •

edited by AlekseyTs

Loading

AlekseyTs commented Feb 14, 2020 •

edited

Loading

CyrusNajmabadi commented Feb 14, 2020 •

edited by AlekseyTs

Loading

CyrusNajmabadi Feb 14, 2020 •

edited by jcouv

Loading

CyrusNajmabadi Feb 14, 2020 •

edited by jcouv

Loading

CyrusNajmabadi Feb 14, 2020 •

edited by AlekseyTs

Loading

CyrusNajmabadi Feb 14, 2020 •

edited by AlekseyTs

Loading

CyrusNajmabadi Feb 14, 2020 •

edited by AlekseyTs

Loading

CyrusNajmabadi Feb 14, 2020 •

edited by AlekseyTs

Loading

CyrusNajmabadi Feb 14, 2020 •

edited by AlekseyTs

Loading

gafter commented Feb 17, 2020 •

edited by AlekseyTs

Loading

jaredpar commented Feb 17, 2020 •

edited by AlekseyTs

Loading

gafter commented Feb 18, 2020 •

edited by AlekseyTs

Loading

RikkiGibson Feb 19, 2020 •

edited

Loading

RikkiGibson commented Feb 19, 2020 •

edited by AlekseyTs

Loading

RikkiGibson Feb 19, 2020 •

edited by AlekseyTs

Loading

RikkiGibson Feb 19, 2020 •

edited by AlekseyTs

Loading

RikkiGibson Feb 20, 2020 •

edited

Loading

RikkiGibson Feb 20, 2020 •

edited by AlekseyTs

Loading

RikkiGibson Feb 20, 2020 •

edited by AlekseyTs

Loading

AlekseyTs Feb 20, 2020 •

edited

Loading

RikkiGibson Feb 20, 2020 •

edited

Loading

agocke Feb 21, 2020 •

edited by AlekseyTs

Loading

agocke Feb 21, 2020 •

edited by AlekseyTs

Loading

agocke Feb 21, 2020 •

edited by AlekseyTs

Loading