Add option to emit nullable metadata for public members only by cston · Pull Request #36398 · dotnet/roslyn

cston · 2019-06-13T06:04:57Z

Relates to #35816 (work items for annotations and metadata compaction)

chsienki · 2019-06-13T17:26:58Z

docs/features/nullable-metadata.md

attributes for private #Resolved

chsienki · 2019-06-13T17:36:23Z

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

You might consider putting a link the nullable attribute spec here, so it's easier to understand the logic #Resolved

chsienki · 2019-06-13T17:40:30Z

src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_NullableMembers.cs

Keep this file?

chsienki · 2019-06-13T17:43:35Z

LGTM, Modulo the failing tests for expression evaluation

jcouv · 2019-06-13T19:52:57Z

docs/features/nullable-metadata.md

@@ -0,0 +1,191 @@
+Nullable Metadata


nit: FWIW, I'd prefer if we merged this doc into the main design doc. #Closed

I'd prefer to see this as a separate document because the metadata spec is now longer and can stand alone.

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

jcouv · 2019-06-13T19:58:16Z

docs/features/nullable-metadata.md

+    [System.AttributeUsage(
+        AttributeTargets.Module |
+        AttributeTargets.Class |
+        AttributeTargets.Delegate |


Delegate [](start = 25, length = 8)

Why allow on Delegate? #Resolved

Why allow on Delegate?

I think, with respect to this attribute, delegates should be valid targets as other classes

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

jcouv · 2019-06-13T20:01:39Z

docs/features/nullable-metadata.md

+```C#
+namespace System.Runtime.CompilerServices
+{
+    public enum NullableMembers


NullableMembers [](start = 16, length = 15)

Out-of-date from our discussion today #Closed

jcouv · 2019-06-13T20:04:25Z

docs/features/nullable-metadata.md

+without explicit `NullableAttribute` attributes.
+
+To reduce the size of metadata, the C#8 compiler will not emit attributes for `private` members,
+and the compiler will only emit attributes for `internal` members if the assembly contains


assembly [](start = 73, length = 8)

module? #Closed

InternalsVisibleToAttribute is an assembly-level attribute.

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

jcouv · 2019-06-13T20:09:49Z

docs/features/nullable-metadata.md

+
+_If necessary, a compiler option could be added in a future release to override the default behavior and
+explicitly emit or drop nullable attributes for `private` or `internal` members._
+


Out-of-date? #Closed

jcouv · 2019-06-13T20:10:55Z

docs/features/nullable-metadata.md

+_If necessary, a compiler option could be added in a future release to override the default behavior and
+explicitly emit or drop nullable attributes for `private` or `internal` members._
+
+## Compatibility


Compatibility [](start = 3, length = 13)

Not related to this PR: when making the compaction change, let's add an entry to the breaking changes doc, even though this is only a break from previous previews.

AlekseyTs · 2019-06-13T20:13:35Z

src/Compilers/Core/Portable/Symbols/Attributes/AttributeDescription.cs

        internal static readonly AttributeDescription AssemblyAlgorithmIdAttribute = new AttributeDescription("System.Reflection", "AssemblyAlgorithmIdAttribute", s_signaturesOfAssemblyAlgorithmIdAttribute);
        internal static readonly AttributeDescription DeprecatedAttribute = new AttributeDescription("Windows.Foundation.Metadata", "DeprecatedAttribute", s_signaturesOfDeprecatedAttribute);
        internal static readonly AttributeDescription NullableAttribute = new AttributeDescription("System.Runtime.CompilerServices", "NullableAttribute", s_signaturesOfNullableAttribute);
+        internal static readonly AttributeDescription NullableMembersAttribute = new AttributeDescription("System.Runtime.CompilerServices", "NullableMembersAttribute", s_signaturesOfNullableMembersAttribute);


NullableMembersAttribute [](start = 54, length = 24)

It doesn't looks like we pay attention to this attribute on import. Are we using this description anywhere? Perhaps we should disallow an explicit attribute application in source. #Closed

Logged #36457.

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

Logged #36457.

Would it make sense to revert changes in this file if they are not used/tested.

In reply to: 293911855 [](ancestors = 293911855,293557364)

This AttributeDescription is used by PEAssemblyBuilder in determining whether to synthesize the type.

In reply to: 293917589 [](ancestors = 293917589,293911855,293557364)

jcouv · 2019-06-13T20:18:58Z

src/Compilers/CSharp/Portable/CSharpCompilationOptions.cs

+        /// (public, protected, and if any [InternalsVisibleTo] attributes, internal members).
+        /// If false, attributes are emitted for all members regardless of visibility.
+        /// </summary>
+        internal bool EmitPublicNullableMetadataOnly { get; private set; }


EmitPublicNullableMetadataOnly [](start = 22, length = 30)

From discussion today, we'll use a feature flag for now. #Resolved

jcouv · 2019-06-13T20:29:54Z

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

            return IsSymbolAccessibleCore(symbol, within, throughTypeOpt, out failedThroughTypeCheck, within.DeclaringCompilation, ref useSiteDiagnostics, basesBeingResolved);
        }

+        internal static bool IsPublicOrInternal(Symbol symbol, out bool isInternal)


IsPublicOrInternal [](start = 29, length = 18)

nit: xml doc would be useful here #Closed

jcouv · 2019-06-13T20:57:21Z

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

-            // Note: we don't need to warn on annotations used without NonNullTypes context for local functions, as this is handled in binding already
+            var compilation = DeclaringCompilation;
+            ParameterHelpers.EnsureIsReadOnlyAttributeExists(compilation, parameters, diagnostics, modifyCompilation: false);
+            ParameterHelpers.EnsureNullableAttributeExists(compilation, this, parameters, diagnostics, modifyCompilation: false);


EnsureNullableAttributeExists [](start = 29, length = 29)

~~Should we guard this call to EnsureNullableAttributeExists with an accessibility check?~~ Never mind, ParameterHelpers does that #Closed

jcouv · 2019-06-13T20:58:38Z

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

-            ParameterHelpers.EnsureNullableAttributeExists(Parameters, diagnostics, modifyCompilation: true);
+            var compilation = DeclaringCompilation;
+            ParameterHelpers.EnsureIsReadOnlyAttributeExists(compilation, Parameters, diagnostics, modifyCompilation: true);
+            ParameterHelpers.EnsureNullableAttributeExists(compilation, this, Parameters, diagnostics, modifyCompilation: true);


EnsureNullableAttributeExists [](start = 29, length = 29)

~~Same question here (should we guard with an access check?)~~ Never mind, ParameterHelpers does that #Closed

jcouv · 2019-06-13T21:20:46Z

...ers/CSharp/Portable/Symbols/Synthesized/SynthesizedEmbeddedNullableMembersAttributeSymbol.cs

+
+namespace Microsoft.CodeAnalysis.CSharp.Symbols
+{
+    internal sealed class SynthesizedEmbeddedNullableMembersAttributeSymbol : SynthesizedEmbeddedAttributeSymbolBase


SynthesizedEmbeddedNullableMembersAttributeSymbol [](start = 26, length = 49)

I'll skip reviewing this file in this iteration, since changes are planned #Closed

jcouv · 2019-06-13T21:26:56Z

src/Compilers/CSharp/Portable/Symbols/Synthesized/SynthesizedFieldSymbolBase.cs

            base.AddSynthesizedAttributes(moduleBuilder, ref attributes);

            CSharpCompilation compilation = this.DeclaringCompilation;
+            var type = this.TypeWithAnnotations;


type [](start = 16, length = 4)

nit: typeWithAnnotations would be better name to avoid confusion with this.Type below. Consider declaring a local var type = typeWithAnnotations.Type to replace this.Type. #Closed

jcouv · 2019-06-13T21:28:12Z

src/Compilers/Test/Utilities/CSharp/CSharpTestBase.cs

 }
 ";

+        protected const string NullableMembersAttributeDefinition = @"


NullableMembersAttributeDefinition [](start = 31, length = 34)

seems unused at the moment #Closed

jcouv · 2019-06-13T21:32:23Z

src/Compilers/Test/Utilities/CSharp/NullableAttributesVisitor.cs

+            VisitList(@namespace.GetMembers());
+        }
+
+        public override void VisitNamedType(NamedTypeSymbol type)


VisitNamedType [](start = 29, length = 14)

Should we visit constraints? (same comment for VisitMethod) #Closed

Visiting constraints doesn't fit easily into this model since we're assuming all symbols are definitions.

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

jcouv · 2019-06-13T21:33:35Z

src/Compilers/Test/Utilities/CSharp/NullableAttributesVisitor.cs

+            return new string(' ', level * 4);
+        }
+
+        private static readonly SymbolDisplayFormat _displayFormat =


_displayFormat [](start = 52, length = 14)

Assuming this is a variant of an existing format, could it be expressed as ExistingFormat.With(change) instead? I think that is easier to maintain when we add new options. #Closed

jcouv · 2019-06-13T21:39:57Z

src/Compilers/Test/Utilities/CSharp/NullableAttributesVisitor.cs

+
+        private void ReportSymbol(Symbol symbol, bool includeAlways = false)
+        {
+            var attributes = (symbol.Kind == SymbolKind.Method) ? ((MethodSymbol)symbol).GetReturnTypeAttributes() : symbol.GetAttributes();


(symbol.Kind == SymbolKind.Method) [](start = 29, length = 34)

nit: consider a type test symbol is MethodSymbol method ? method. ... #Closed

jcouv · 2019-06-13T21:45:04Z

src/Compilers/Test/Utilities/CSharp/NullableAttributesVisitor.cs

+                return;
+            }
+            ReportContainingSymbols(symbol.ContainingSymbol);
+            ReportSymbol(symbol, includeAlways: true);


, includeAlways: true [](start = 31, length = 21)

I didn't understand this part. We always want to report containing symbols? #Closed

When we need to report a specific symbol, we first report all ancestors, from the outermost type down.

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

AlekseyTs · 2019-06-14T18:09:29Z

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

+
+                symbol = symbol.ContainingType;
+            }
+            while (!(symbol is null));


!(symbol is null) [](start = 19, length = 17)

symbol is object? #Closed

AlekseyTs · 2019-06-14T18:11:48Z

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

+        /// Returns true if the symbol is effectively public or internal based on
+        /// the declared accessibility of the symbol and any containing symbols.
+        /// </summary>
+        internal static bool IsPublicOrInternal(Symbol symbol, out bool isInternal)


IsPublicOrInternal [](start = 29, length = 18)

Consider including "effectively" in the name for clarity. Something like "IsEffectivelyPublicOrInternal". #Closed

AlekseyTs · 2019-06-14T18:19:50Z

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

+            Debug.Assert(symbol.IsDefinition);
+
+            var sourceAssembly = SourceAssembly;
+            if (symbol.ContainingAssembly != sourceAssembly)


if (symbol.ContainingAssembly != sourceAssembly) [](start = 12, length = 48)

Is this check for just in case, or do we have a scenario when it is significant? Consider switching to SourceModule comparison instead. #Closed

We hit this in the EE.

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

We hit this in the EE.

Then comparing the module is the right check instead, I think.

In reply to: 293924981 [](ancestors = 293924981,293924012)

AlekseyTs · 2019-06-14T18:23:39Z

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

            {
-                if (returnType.NeedsNullableAttribute())
+                if (compilation.ShouldEmitNullableAttributes(lambdaSymbol) &&
+                    returnType.NeedsNullableAttribute())


returnType.NeedsNullableAttribute() [](start = 20, length = 35)

Should we stop emitting nullable attributes for any synthesized code not meant for direct consumption?

Logged #36466.

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

AlekseyTs · 2019-06-14T18:32:56Z

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

            foreach (var parameter in parameters)
            {
-                if (parameter.TypeWithAnnotations.NeedsNullableAttribute())
+                if (compilation.ShouldEmitNullableAttributes(container) && parameter.TypeWithAnnotations.NeedsNullableAttribute())


compilation.ShouldEmitNullableAttributes(container) [](start = 20, length = 51)

It feel like this condition can be taken out of the loop. If we don't want to evaluate this value for an empty parameters array, we could check that too. #Closed

AlekseyTs · 2019-06-14T19:08:14Z

src/Compilers/CSharp/Portable/Emitter/Model/PEAssemblyBuilder.cs

+
+            if ((needsAttributes & EmbeddedAttributes.NullablePublicOnlyAttribute) != 0)
+            {
+                CreateEmbeddedAttributeItselfIfNeeded(diagnostics);


CreateEmbeddedAttributeItselfIfNeeded(diagnostics) [](start = 16, length = 50)

Minor, I guess now we can take this out of all the '''ifs''' and call this once before them if needsAttributes is not 0. #Closed

Good catch, thanks.

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

AlekseyTs · 2019-06-14T19:29:54Z

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

        }

-        internal void EnsureIsReadOnlyAttributeExists(DiagnosticBag diagnostics, Location location, bool modifyCompilation)
+        private void EnsureEmbeddedAttributeExists(EmbeddedAttributes attribute, DiagnosticBag diagnostics, Location location, bool modifyCompilation)


EnsureEmbeddedAttributeExists [](start = 21, length = 29)

The name is confusing:

We have an EmbeddedAttribute

The attributes are not always embedded.

Consider renaming to something like "EnsureEmbeddableAttributeExists" #Closed

AlekseyTs · 2019-06-14T19:31:13Z

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

+namespace Microsoft.CodeAnalysis.CSharp
+{
+    [Flags]
+    internal enum EmbeddedAttributes


EmbeddedAttributes [](start = 18, length = 18)

"EmbeddableAttributes"? #Closed

That's a better name, thanks.

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

AlekseyTs · 2019-06-14T19:37:33Z

src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs

        }

-        internal void EnsureIsReadOnlyAttributeExists()
+        private void EnsureEmbeddedAttributeExists(EmbeddedAttributes attribute)


EnsureEmbeddedAttributeExists [](start = 21, length = 29)

"EnsureEmbeddableAttributeExists"? #Closed

AlekseyTs · 2019-06-14T19:41:08Z

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter.cs


-            bool constraintsNeedNullableAttribute = typeParameters.Any(
-               typeParameter => ((SourceTypeParameterSymbolBase)typeParameter).ConstraintsNeedNullableAttribute());
+            if (_factory.CompilationState.Compilation.ShouldEmitNullableAttributes(localFunction))


if (_factory.CompilationState.Compilation.ShouldEmitNullableAttributes(localFunction)) [](start = 12, length = 86)

Similar suggestion as for lambdas.

AlekseyTs · 2019-06-14T19:47:43Z

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

            }

-            if (returnType.NeedsNullableAttribute())
+            if (compilation?.ShouldEmitNullableAttributes(this) == true &&


compilation? [](start = 16, length = 12)

Can compilation ever be null and why other places do not guard? #Closed

Yes, compilation may be null from the EE.

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

AlekseyTs · 2019-06-14T20:05:49Z

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

+            {
+                var compilation = DeclaringCompilation;
+                return compilation.EmitNullablePublicOnly &&
+                    compilation.IsFeatureEnabled(MessageID.IDS_FeatureNullableReferenceTypes);


compilation.IsFeatureEnabled(MessageID.IDS_FeatureNullableReferenceTypes) [](start = 20, length = 73)

Having this property on the Module symbol as well feels confusing, especially that it has extra conditions. Effectively, there is an inconsistency between other users of compilation.EmitNullablePublicOnly and this code. Consider incorporating the feature check into the compilation's property and getting rid of this property. #Closed

Alternatively, consider renaming this property to EmitNullablePublicOnlyAttribute

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

AlekseyTs

LGTM (iteration 13)

jcouv · 2019-06-14T22:41:32Z

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

+            {
+                if (!_lazyEmitNullablePublicOnly.HasValue())
+                {
+                    bool value = SyntaxTrees.FirstOrDefault()?.Options?.Features?.ContainsKey("nullablePublicOnly") == true;


SyntaxTrees.FirstOrDefault()?.Options?.Features?.ContainsKey("nullablePublicOnly") == true; [](start = 33, length = 91)

We may already have a way of checking feature flags. I'm surprised we'd need to do this "by hand" here.

Also, should we be checking for LangVersion? #Closed

I couldn't find an appropriate helper method for checking Features.

Regarding language version, is it necessary to add that restriction here? Presumably language version will produce the necessary warnings and errors during binding.

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

You're right, we don't have a helper. IOperations did the same...

internal override bool IsIOperationFeatureEnabled() { var options = (CSharpParseOptions)this.SyntaxTrees.FirstOrDefault()?.Options; return options?.IsFeatureEnabled(MessageID.IDS_FeatureIOperation) ?? false; }

For LangVersion, I agree too. If you're in C# 7.3 and don't nullable annotations, then the feature flag is a no-op, so no need to report a diagnostic.

In reply to: 294017389 [](ancestors = 294017389,294014629)

jcouv · 2019-06-14T22:50:08Z

src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_NullablePublicOnly.cs

+    {
+        [Fact]
+        public void ExplicitAttribute_FromSource()
+        {


{ [](start = 8, length = 1)

[NullablePublicOnly] should be disallowed in source. Do we have a test for that? #Pending

jcouv · 2019-06-14T23:04:27Z

src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs

-            {
-                _needsGeneratedIsUnmanagedAttribute_Value = true;
-            }
+        internal void EnsureIsUnmanagedAttributeExists()


EnsureIsUnmanagedAttributeExists [](start = 22, length = 32)

nit: consider inlining this method (only one use as far as I can tell).
Comment may be applicable for other Ensure... methods as well.

jcouv · 2019-06-14T23:11:24Z

src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_NullablePublicOnly.cs

+            CompileAndVerify(comp, symbolValidator: AssertNoNullablePublicOnlyAttribute);
+
+            comp = CreateCompilation(source, options: options, parseOptions: parseOptions.WithFeature("nullablePublicOnly"));
+            CompileAndVerify(comp, symbolValidator: AssertNullablePublicOnlyAttribute);


symbolValidator: AssertNullablePublicOnlyAttribute); [](start = 35, length = 52)

consider validating that no NullablePublicOnly attribute appears on source symbols (validator: AssertNoNullablePublicOnlyAttribute)

jcouv

LGTM Thanks (iteration 16)

…-types * dotnet/master: (63 commits) Fix stack overflow in requesting syntax directives (dotnet#36347) crash on ClassifyUpdate for EventFields (dotnet#35962) Disable move type when the options service isn't present (dotnet#36334) Fix crash where type inference doing method inference needs to drop nullability Fix parsing bug in invalid using statements (dotnet#36428) Do not suggest or diagnose use compound assignment when right hand of binary operator is a throw expression Add option to emit nullable metadata for public members only (dotnet#36398) Added null checks on F# external access services (dotnet#36469) Deal with discovering extra .editorconfig files Re-enable MSBuildWorkspaceTests.TestEditorConfigDiscovery Add support to VisualStudioMSBuildInstalled to support minimum versions Fix configuration of accessibilities in editorconfig Shorten a resource ID Revert "Extract the RDT implementation for Misc files and VS open file tracker" Add nullability support to use local function Add EditorFeatures.WPF dependency to F# ExternalAccess Ensure NullableWalker.AsMemberOfType locates the right new container for the member. (dotnet#36406) Replace `dynamic` with `object` when substituting constraints. (dotnet#36379) Add some string descriptions Adjust type of out var based on parameter state (dotnet#36284) ...

cston requested a review from a team as a code owner June 13, 2019 06:04

jcouv added Area-Compilers Feature - Nullable Reference Types Nullable Reference Types labels Jun 13, 2019

cston force-pushed the private-members branch from 6f3496e to ce358a7 Compare June 13, 2019 15:08

chsienki approved these changes Jun 13, 2019

View reviewed changes

cston added 4 commits June 13, 2019 12:11

Add option to emit nullable metadata for public members only

f1f48e7

Fix tests

eb691f4

PR feedback

da97ddc

Fix tests

5be3827

cston force-pushed the private-members branch from ceb8115 to 5be3827 Compare June 13, 2019 19:36

jcouv reviewed Jun 13, 2019

View reviewed changes

AlekseyTs reviewed Jun 13, 2019

View reviewed changes

jcouv reviewed Jun 13, 2019

View reviewed changes

jcouv added this to the 16.2.P4 milestone Jun 13, 2019

jcouv reviewed Jun 13, 2019

View reviewed changes

AlekseyTs reviewed Jun 14, 2019

View reviewed changes

PR feedback

aa025b8

AlekseyTs reviewed Jun 14, 2019

View reviewed changes

cston added 2 commits June 14, 2019 11:47

PR feedback

6cd04bb

PR feedback

8b06fb7

AlekseyTs reviewed Jun 14, 2019

View reviewed changes

PR feedback

d3e14c2

AlekseyTs reviewed Jun 14, 2019

View reviewed changes

AlekseyTs approved these changes Jun 14, 2019

View reviewed changes

PR feedback

7edf556

cston mentioned this pull request Jun 14, 2019

Avoid emitting NullableAttribute annotations for lambdas and local functions #36466

Open

cston added 2 commits June 14, 2019 14:06

Rename property

331ad55

Misc.

85a9cb2

jcouv reviewed Jun 14, 2019

View reviewed changes

jcouv approved these changes Jun 14, 2019

View reviewed changes

cston merged commit 0bc5071 into dotnet:master Jun 14, 2019

cston deleted the private-members branch June 14, 2019 23:29

cston mentioned this pull request Jun 25, 2019

Reduce the impact of nullable attributes in metadata #35888

Closed


		_If necessary, a compiler option could be added in a future release to override the default behavior and
		explicitly emit or drop nullable attributes for `private` or `internal` members._

Conversation

cston commented Jun 13, 2019 • edited by jcouv Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

chsienki Jun 13, 2019 • edited by cston Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

chsienki Jun 13, 2019 • edited by cston 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!

chsienki commented Jun 13, 2019

Uh oh!

jcouv Jun 13, 2019 • 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!

jcouv Jun 13, 2019 • edited by cston 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!

jcouv Jun 13, 2019 • 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 Jun 13, 2019 • 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!

jcouv Jun 13, 2019 • 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!

AlekseyTs Jun 13, 2019 • 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!

jcouv Jun 13, 2019 • edited by cston 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 Jun 13, 2019 • 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 Jun 13, 2019 • 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 Jun 13, 2019 • 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 Jun 13, 2019 • 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 Jun 13, 2019 • 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 Jun 13, 2019 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

cston commented Jun 13, 2019 •

edited by jcouv

Loading

chsienki Jun 13, 2019 •

edited by cston

Loading

chsienki Jun 13, 2019 •

edited by cston

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited by cston

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

AlekseyTs Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited by cston

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

jcouv Jun 13, 2019 •

edited

Loading

AlekseyTs Jun 14, 2019 •

edited

Loading

AlekseyTs Jun 14, 2019 •

edited

Loading

AlekseyTs Jun 14, 2019 •

edited

Loading

AlekseyTs Jun 14, 2019 •

edited

Loading

AlekseyTs Jun 14, 2019 •

edited

Loading

AlekseyTs Jun 14, 2019 •

edited

Loading