Parsing Using Var by fayrose · Pull Request #28315 · dotnet/roslyn

fayrose · 2018-07-05T22:19:34Z

Parsing changes for the using var feature ahead of LDM Monday.

CyrusNajmabadi · 2018-07-05T22:38:07Z

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

+            else if (node.UsingKeyword != default)
+            {
+                kind = LocalDeclarationKind.UsingVariable;
+            }


this looks to be going beyond just a parsing change (as the title of the PR implies).

CyrusNajmabadi · 2018-07-05T22:39:02Z

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

+                            {
+                                kind = LocalDeclarationKind.RegularVariable;
+                            }
+                                foreach (var vdecl in decl.Declaration.Variables)


in general we like a blank like after a }.

this is indented improperly.

avoid abbrs when possible. you can just say "var variableDeclaration" #Resolved

I just accidentally indented a line or two due to copying and pasting code between branches to isolate parsing from the rest of the feature. Anything including vdecl is not my code. Should I change it regardless? #Resolved

No. Once you fix the indentation, just leave the code alone if it isn't necessary to change for your PR. Thanks! :) #Resolved

jcouv · 2018-07-05T22:39:23Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+            Assert.NotNull(us.Declaration);
+            Assert.Equal("f ? x = a", us.Declaration.ToString());
+
+        }


Nit: bunch of unnecessary empty lines here and elsewhere.

Also, for testing syntax, have you tried tests that use this format: TernaryVersusDeclaration_05?
Those will show and validate the structure of the parse tree. A small trick to help writing such tests is to uncomment //#define PARSING_TESTS_DUMP in the base file (ParsingTests) so that the test output gives you the expected code. #Closed

CyrusNajmabadi · 2018-07-05T22:39:46Z

src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs


  internal sealed partial class LocalDeclarationStatementSyntax : StatementSyntax
  {
+    internal readonly SyntaxToken usingKeyword;


i'm not s huge fan of repurposing this node in this manner. It feels more appropriate as a new sort of node.
But i could be convinced otherwise. #Closed

I rather like it. Tagging @gafter for advice on the shape of the syntax tree (extend local declarations, or create a dedicated kind of node?).

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

This is usually what we do when we augment nodes. For instance, when we added ref locals we didn't add new types of local declarations, we just added optional ref modifiers. I think it's the same situation here. #Resolved

Yeah, i'm on the fence. Something feels... 'wonky' here. Perhaps because 'using' bridges between two things (using-statements, and local-var-statements). That's unlike 'ref'.

That said, this may just need some time on my part to get used to it. So this is not at all strong pushback. If the team feels like this is "good", then i have no objection. #Resolved

Could it be parsed into Modifiers on LocalDeclaration? Currently Modifiers is only used for const.

CyrusNajmabadi · 2018-07-05T22:40:20Z

src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs

+        public LocalDeclarationStatementSyntax Update(SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
+        {
+            return Update(default(SyntaxToken), modifiers, declaration, semicolonToken);
+        }


nit. use =>

CyrusNajmabadi · 2018-07-05T22:40:26Z

src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs

@@ -21,5 +29,10 @@ public static StackAllocArrayCreationExpressionSyntax StackAllocArrayCreationExp
        {
            return StackAllocArrayCreationExpression(stackAllocKeyword, type, default(InitializerExpressionSyntax));
        }


newline after this }

CyrusNajmabadi · 2018-07-05T22:40:34Z

src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs

            return StackAllocArrayCreationExpression(stackAllocKeyword, type, default(InitializerExpressionSyntax));
        }
+        public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
+        {


nit: consider =>

CyrusNajmabadi · 2018-07-05T22:40:42Z

src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs

+        {
+            return LocalDeclarationStatement(default(SyntaxToken), modifiers, declaration, semicolonToken);
+        }
+


reomve this blank line.

CyrusNajmabadi · 2018-07-05T22:40:58Z

src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs

+    {
+        public LocalDeclarationStatementSyntax Update(SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
+        {
+            return Update(default(SyntaxToken), modifiers, declaration, semicolonToken);


you should be able to just use 'default' instead of 'default(SyntaxToken)' right?

CyrusNajmabadi · 2018-07-05T22:41:24Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+
+        }
+
+


too many blank lines.

CyrusNajmabadi · 2018-07-05T22:41:31Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+            Assert.Equal(SyntaxKind.UsingKeyword, us.UsingKeyword.Kind());
+            Assert.NotNull(us.Declaration);
+            Assert.Equal("f ? x = a", us.Declaration.ToString());
+


unnecessary blank line.

jcouv · 2018-07-05T22:54:39Z

src/Compilers/CSharp/Portable/Syntax/Syntax.xml

+    <Field Name="UsingKeyword" Type="SyntaxToken" Optional="true">
+      <Kind Name="UsingKeyword"/>
+    </Field>
    <Field Name="Modifiers" Type="SyntaxList&lt;SyntaxToken&gt;">


Modifiers [](start = 17, length = 9)

I see that the parsing logic tolerates putting modifiers on local declarations. Can you test such scenarios with using locals?
I assume all modifiers in this position should be errors. Is that correct? #Closed

Well, I would assume they would be binding errors, not syntax errors.

Looks like we still need a test for this case.

I think we should test all of the following cases:

using ref int x = ref y; using ref readonly int x = ref y; using ref var x = ref y; using ref var x = y; using readonly var x, y = ref z;

agocke · 2018-07-05T22:56:01Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+            var text = "using T a = b;";
+            var statement = this.ParseStatement(text);
+
+            Assert.NotNull(statement);


I think these tests would be far more readable if you use the UsingTree helper. I think most of the existing tests are written in this style because they existed before that helper did.

Done and pushed; have both versions for now.

agocke · 2018-07-05T22:57:09Z

src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs


  internal sealed partial class LocalDeclarationStatementSyntax : StatementSyntax
  {
+    internal readonly SyntaxToken usingKeyword;


This is usually what we do when we augment nodes. For instance, when we added ref locals we didn't add new types of local declarations, we just added optional ref modifiers. I think it's the same situation here. #Resolved

agocke · 2018-07-05T22:59:14Z

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

                            var decl = (LocalDeclarationStatementSyntax)innerStatement;
-                            LocalDeclarationKind kind = decl.IsConst ? LocalDeclarationKind.Constant : LocalDeclarationKind.RegularVariable;
-                            foreach (var vdecl in decl.Declaration.Variables)
+                            LocalDeclarationKind kind;


I don't think these binder changes should be included. Right now we're only testing parsing.

CyrusNajmabadi · 2018-07-06T00:14:46Z

src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs

+
+        public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
+            => LocalDeclarationStatement(default(SyntaxToken), modifiers, declaration, semicolonToken);
+


extra newline.

jcouv · 2018-07-06T00:40:03Z

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

+                            {
+                                kind = LocalDeclarationKind.Constant;
+                            }
+                            else if (decl.UsingKeyword != default(SyntaxToken))


SyntaxToken [](start = 66, length = 11)

~~Nit: you could use decl.UsingKeyword != default here (omit the type)~~Never mind, the binder changes should be undone for this PR.
#Resolved

jcouv · 2018-07-06T00:41:07Z

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

                            var decl = (LocalDeclarationStatementSyntax)innerStatement;
-                            LocalDeclarationKind kind = decl.IsConst ? LocalDeclarationKind.Constant : LocalDeclarationKind.RegularVariable;
+                            LocalDeclarationKind kind;
+                            if (decl.IsConst)


~~Could you test the syntax tree when you have both const and using?~~ Never mind, the binder changes should be undone for this PR. #Resolved

agocke · 2018-07-10T22:07:35Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken);
+                        N(SyntaxKind.VariableDeclarator);


Indentation (nesting) looks wrong. I think the variable declarator should be directly beneath VariableDeclaration.

agocke · 2018-07-10T22:09:10Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                {
+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken);


N( takes a second optional parameter here so you can verify the correct IdentifierToken (should be T I think). You should use it for all the IdentifierTokens.

agocke · 2018-07-10T22:11:32Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken);
+                        N(SyntaxKind.VariableDeclarator);


Indentation also looks wrong here.

agocke · 2018-07-10T22:13:02Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                    N(SyntaxKind.IdentifierName);
+                    {
+                        N(SyntaxKind.IdentifierToken);
+                        N(SyntaxKind.VariableDeclarator);


Indentation looks wrong.

agocke · 2018-07-10T22:16:40Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                        }
+
+                    }
+                    N(SyntaxKind.QuestionToken);


It looks like QuestionToken should be inside the NullableType

agocke · 2018-07-10T22:17:16Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                            N(SyntaxKind.IdentifierToken);
+                        }
+                    }
+                    N(SyntaxKind.QuestionToken);


QuestionToken is part of NullableType

agocke · 2018-07-10T22:22:27Z

src/Compilers/CSharp/Portable/Syntax/Syntax.xml

+    <Field Name="UsingKeyword" Type="SyntaxToken" Optional="true">
+      <Kind Name="UsingKeyword"/>
+    </Field>
    <Field Name="Modifiers" Type="SyntaxList&lt;SyntaxToken&gt;">


Looks like we still need a test for this case.

I think we should test all of the following cases:

using ref int x = ref y; using ref readonly int x = ref y; using ref var x = ref y; using ref var x = y; using readonly var x, y = ref z;

agocke · 2018-07-11T20:18:56Z

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

        private StatementSyntax ParseLocalDeclarationStatement()
        {
            var mods = _pool.Allocate();
+            var usingKeyword = this.CurrentToken.Kind == SyntaxKind.UsingKeyword ? this.EatToken() : null;


Might as well put this at the top and keep the mods declaration and ParseDeclarationModifiers together.

agocke · 2018-07-11T20:19:53Z

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

            {
                kind = LocalDeclarationKind.Constant;
            }
-


This doesn't look necessary.

agocke · 2018-07-11T20:20:32Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                N(SyntaxKind.UsingKeyword);
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.IdentifierName);


Missing strings for the IdentifierNames

agocke · 2018-07-11T20:20:54Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                N(SyntaxKind.UsingKeyword);
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.IdentifierName);


agocke · 2018-07-11T20:21:12Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                N(SyntaxKind.UsingKeyword);
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.IdentifierName);


agocke · 2018-07-11T20:23:36Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                    }
+                    N(SyntaxKind.VariableDeclarator);
+                    {
+                        N(SyntaxKind.IdentifierToken);


agocke · 2018-07-11T20:23:53Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                            N(SyntaxKind.RefExpression);
+                            {
+                                N(SyntaxKind.RefKeyword);
+                                N(SyntaxKind.IdentifierName);


agocke · 2018-07-11T20:24:00Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                    N(SyntaxKind.RefType);
+                    {
+                        N(SyntaxKind.RefKeyword);
+                        N(SyntaxKind.IdentifierName);


agocke · 2018-07-11T20:24:13Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                    N(SyntaxKind.RefType);
+                    {
+                        N(SyntaxKind.RefKeyword);
+                        N(SyntaxKind.IdentifierName);


agocke · 2018-07-11T20:24:28Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                N(SyntaxKind.ReadOnlyKeyword);
+                N(SyntaxKind.VariableDeclaration);
+                {
+                    N(SyntaxKind.IdentifierName);


agocke

LGTM aside from nesting problem.

agocke · 2018-07-11T21:30:41Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+                        }
+                    }
+                }
+                N(SyntaxKind.CommaToken);


I believe both the comma and variable declarator below are part of the variable declaration

jaredpar · 2018-07-12T00:27:15Z

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

@@ -8243,6 +8245,7 @@ private StatementSyntax ParseLocalDeclarationStatement()

                var semicolon = this.EatToken(SyntaxKind.SemicolonToken);
                return _syntaxFactory.LocalDeclarationStatement(


We should add a PROTOTYPE comment here to make sure we're okay with using on a local declaration being handled differently than other modifiers like ref, const, etc ... Fine for this PR but should have a comment tracking with the API design.

jaredpar · 2018-07-12T00:29:01Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+        [Fact]
+        public void TestUsingVarSpecialCase3()
+        {
+            var text = "using f ? x, y;";


What is this doing? I'm unsure what exactly is happening here.

Ah I see. It's a type f? there is just a space before the ?.

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

jaredpar

We should add a PROTOTYPE comment to track the API decision but looks good otherwise.

jcouv · 2018-07-13T21:48:00Z

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

                    }
                }
-
+                // PROTOTYPE


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

For some reason, we typically use the branch name in PROTOTYPE markers. But, it's more convenient without. @jaredpar, OK with simple "PROTOTYPE"?

Also, can you expand the comment to say the purpose of the marker? What is the issue?

jcouv · 2018-07-13T21:48:44Z

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs

+        [Fact]
+        public void TestUsingVarReadonlyMultipleDeclarations()
+        {
+            UsingStatement("using readonly var x, y = ref z;", CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_2),


using readonly [](start = 28, length = 14)

Could you also test with reverse order? readonly using ... (this shows that using is not just parsed as a modifier)

jcouv · 2018-07-13T21:50:07Z

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

 ";
            CreateCompilation(source).VerifyDiagnostics(
-                // (6,8): error CS1003: Syntax error, '(' expected
+                // (6,8): error CS1031: Type expected


// (6,8): error CS1031: Type expected [](start = 16, length = 37)

The diagnostic quality here isn't the best. You could also type a parenthesis. Maybe add a PROTOTYPE marker to revisit.

jcouv · 2018-07-13T21:53:04Z

src/Compilers/CSharp/Portable/Syntax/StackAllocArrayCreationExpressionSyntax.cs

@@ -7,9 +7,13 @@ namespace Microsoft.CodeAnalysis.CSharp.Syntax
    public partial class StackAllocArrayCreationExpressionSyntax


I see that the stackalloc syntax derives from the local declaration syntax. Could you add a corresponding parsing test (using and stackalloc)? And also take a note to do a full test on that scenario (not just parsing).

Can you or @agocke start a test plan issue for this feature work, if you don't have one already? It is useful to collect test ideas.

jcouv

LGTM with some test suggestions and nits (can be addressed in next PR). Thanks

Parsing

7fb24dc

fayrose added the Area-Compilers label Jul 5, 2018

fayrose requested a review from a team as a code owner July 5, 2018 22:19

fayrose assigned jaredpar and agocke Jul 5, 2018

jcouv added this to the 16.0 milestone Jul 5, 2018

CyrusNajmabadi reviewed Jul 5, 2018

View reviewed changes

jcouv reviewed Jul 5, 2018

View reviewed changes

CyrusNajmabadi reviewed Jul 5, 2018

View reviewed changes

src/Compilers/CSharp/Test/Syntax/Parsing/StatementParsingTests.cs Outdated

}

Copy link

Contributor

CyrusNajmabadi Jul 5, 2018

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

too many blank lines.

CyrusNajmabadi reviewed Jul 5, 2018

View reviewed changes

jcouv reviewed Jul 5, 2018

View reviewed changes

agocke reviewed Jul 5, 2018

View reviewed changes

Lauren Rosenberg added 2 commits July 5, 2018 16:01

Requested changes

b4608e6

Most of statement parsing tests

81632c1

CyrusNajmabadi reviewed Jul 6, 2018

View reviewed changes

jcouv reviewed Jul 6, 2018

View reviewed changes

Lauren Rosenberg added 3 commits July 6, 2018 10:37

Special case tree tests

50779d4

Reverts binder changes

3d73621

Minor fix

686f245

agocke mentioned this pull request Jul 9, 2018

Proposal: Allow using statement to structurally match IDisposable on ref structs (16.3, Core 3) dotnet/csharplang#1623

Open

5 tasks

Test fix

249b490

agocke reviewed Jul 10, 2018

View reviewed changes

More tests and bug fix

68426cf

agocke reviewed Jul 11, 2018

View reviewed changes

Lauren Rosenberg added 2 commits July 11, 2018 14:03

Differentiated IdentifierNames

208e8db

Added IdentifierToken differentiators

a2b5d0f

agocke approved these changes Jul 11, 2018

View reviewed changes

Indenting fix

70bfd1f

jaredpar reviewed Jul 12, 2018

View reviewed changes

jaredpar approved these changes Jul 12, 2018

View reviewed changes

added prototype comment

81d4440

jaredpar approved these changes Jul 12, 2018

View reviewed changes

jcouv reviewed Jul 13, 2018

View reviewed changes

jcouv approved these changes Jul 13, 2018

View reviewed changes

fayrose merged commit 98e5398 into dotnet:features/enhanced-using Jul 16, 2018

fayrose deleted the using-var-parsing branch July 16, 2018 20:25


		public static LocalDeclarationStatementSyntax LocalDeclarationStatement(SyntaxTokenList modifiers, VariableDeclarationSyntax declaration, SyntaxToken semicolonToken)
		=> LocalDeclarationStatement(default(SyntaxToken), modifiers, declaration, semicolonToken);

		@@ -8243,6 +8245,7 @@ private StatementSyntax ParseLocalDeclarationStatement()

		var semicolon = this.EatToken(SyntaxKind.SemicolonToken);
		return _syntaxFactory.LocalDeclarationStatement(

		@@ -7,9 +7,13 @@ namespace Microsoft.CodeAnalysis.CSharp.Syntax
		public partial class StackAllocArrayCreationExpressionSyntax

Conversation

fayrose commented Jul 5, 2018

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CyrusNajmabadi Jul 5, 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!

fayrose Jul 5, 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!

CyrusNajmabadi Jul 5, 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!

jcouv Jul 5, 2018 • 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!

CyrusNajmabadi Jul 5, 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!

Choose a reason for hiding this comment

Uh oh!

agocke Jul 5, 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!

CyrusNajmabadi Jul 5, 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!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jcouv Jul 5, 2018 • 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!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

agocke Jul 5, 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!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jcouv Jul 6, 2018 • 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 Jul 6, 2018 • 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!

agocke Jul 10, 2018 • edited Loading Uh oh! There was an error while loading. Please reload this page.

CyrusNajmabadi Jul 5, 2018 •

edited by jcouv

Loading

fayrose Jul 5, 2018 •

edited by jcouv

Loading

CyrusNajmabadi Jul 5, 2018 •

edited by jcouv

Loading

jcouv Jul 5, 2018 •

edited

Loading

CyrusNajmabadi Jul 5, 2018 •

edited by jcouv

Loading

agocke Jul 5, 2018 •

edited by jcouv

Loading

CyrusNajmabadi Jul 5, 2018 •

edited by jcouv

Loading

jcouv Jul 5, 2018 •

edited

Loading

agocke Jul 5, 2018 •

edited by jcouv

Loading

jcouv Jul 6, 2018 •

edited

Loading

jcouv Jul 6, 2018 •

edited

Loading

agocke Jul 10, 2018 •

edited

Loading