Nullability annotations for bindables #5099

huoyaoyuan · 2022-04-14T05:50:41Z

Not bothering the thin value type wrappers (BindableInt etc).
The Value and DefaultValue property is annotated the same as type parameter, allowing both Bindable<Class> and Bindable<Class?>.

Risks

The default constructor of Bindable<T> can introduce null to non-null annotated properties. This does not change existing behavior, but provides a fake sense of safety. In the other hand, annotating Value to be always nullable can introduce too much noise for consumers. The best option should be warning for such constructor call, but it's not possible yet.

The resharper warning is somehow too aggressive that assuming not-yet annotated code to be non-nullable. It warns here where it should be ValueChangedEvent<IAudioMixer?>. I tend to think it's not wrong to be defensive for not-yet annotated code.

bdach · 2022-04-16T17:09:13Z

This pull really ought to include a preview of what the game-side changes will be to eliminate new nullability warnings. I cannot imagine there are no nullability-related warnings that are going to arise game-side if this is to be merged...?

osu.Framework/Bindables/Bindable.cs

bdach · 2022-04-16T17:22:45Z

osu.Framework/Bindables/Bindable.cs

+            // It lacks a way to represent "warn if called with non-nullable T".
+            // Not verifying to avoid breaking tons of existing usages.


Not sure what this comment means - is it trying to say that it is impossible to force the user to pass a non-null default if they're creating a Bindable<T> with a non-nullable inner type?

Yes. That's what I mentioned in risk of PR description.

Probably just remove this comment and the derived ctor (BindableWithCurrent, etc), as they read bad.

Then we should check the usage of this ctor, and don't forget DI constructed ones.
Let lazy initialised instances to use explicit null! should be fine, but it may require a lot of code change.

Sorry, I meant just removing the comments, not the ctors altogether. I'm not sure whether anything can (ever?) be done here.

Could use the IsNullable() overloads, but they have too much overhead.

Are the .NET team aware of this? It doesn't seem like an esoteric use case.

This is the same pain of default(ImmutableArray<T>). In that case ImmutableArray was designed for heavily used in hot path, so the decision is to let NRE blows up.

This is also a delay initialisation problem like DI. There is also no guarantee that initialisation (load) must be invoked after creating the object.

AFAIK, tracking delay initialisation is too far for language design.

I think we should look at the usages to see if delay initilisation of bindable can be avoided, and convert to delay create the Bindable instance instead.

Another consideration: we may remove the default parameter, and add factories for creating bindables. For example:

// not providing default value will always provide a nullable bindable Bindable<T?> Create<T>() => new Bindable<T?>(null);

I wouldn't call this delayed initialisation. Surely it's within the scope of NRT/the language to determine that T x = default is null in a context where nulls aren't allowed, so the param must be provided? In addition, I'd hope that T x = default! bypasses this behaviour as it does for T x = null!.

A Roslyn analyser for this would be quite simple to craft, and I'll do it myself provided the time.

Just to make sure we're on the same page, I would require cases like this to provide a parameter. The rules of constructing bindables should be simple:

// <T> is <int>, param not required. public readonly Bindable<int> MyBindable1 = new Bindable<int>(); // <T> is <int?>, param not required. public readonly Bindable<int?> MyBindable2 = new Bindable<int?>(); // <T> is <object>, param required. public readonly Bindable<object> MyBindable3 = new Bindable<object>(new object()); // <T> is <object?>, param not required. public readonly Bindable<object?> MyBindable4 = new Bindable<object?>(); public MyObject() { // Same rules as above. MyBindable1 = new Bindable<int>(); MyBindable2 = new Bindable<int?>(); MyBindable3 = new Bindable<object>(new object()); MyBindable4 = new Bindable<object?>(); }

Anything else is incorrect use:

// Incorrect public readonly Bindable<object> MyBindable1 = new Bindable<object>(); public MyObject() { MyBindable1.Value = new object(); }

Yes, this is the desired behavior I want. A custom analyser is good and we don't need to do workarounds about language features.

bdach · 2022-04-16T17:24:49Z

osu.Framework/Bindables/Bindable.cs

@@ -359,8 +364,7 @@ public void UnbindBindings()

        internal virtual void UnbindAllInternal()
        {
-            if (isLeased)
-                leasedBindable.Return();
+            leasedBindable?.Return();


Not sure why this was touched in this pull given that this has very little to do with nullability.

Because the isLeased property is not annotated with MemberNotNull, and we haven't removed netstandard yet, it's a bit complex to add the annotation. Since the property is private, I'm simply adjusting its usage.

I'd probably prefer:

if (isLeased) { Debug.Assert(leasedBindable != null); leasedBindable.Return(); }

Or maybe leasedBindable.AsNonNull().Return() also works.

Co-authored-by: Bartłomiej Dach <[email protected]>

huoyaoyuan · 2022-04-30T13:25:15Z

There's no warning when building game repo, since most of them haven't enabled nullability yet.

InspectCode reports some warnings. There's the diff to fix:

diff --git a/osu.Game/Overlays/Chat/ChatTextBar.cs b/osu.Game/Overlays/Chat/ChatTextBar.cs
index ef20149dac..029c3a1b7c 100644
--- a/osu.Game/Overlays/Chat/ChatTextBar.cs
+++ b/osu.Game/Overlays/Chat/ChatTextBar.cs
@@ -26,7 +26,7 @@ public class ChatTextBar : Container
         public event Action<string>? OnSearchTermsChanged;

         [Resolved]
-        private Bindable<Channel> currentChannel { get; set; } = null!;
+        private Bindable<Channel?> currentChannel { get; set; } = null!;

         private OsuTextFlowContainer chattingTextContainer = null!;
         private Container searchIconContainer = null!;
@@ -126,7 +126,7 @@ protected override void LoadComplete()

             currentChannel.BindValueChanged(change =>
             {
-                Channel newChannel = change.NewValue;
+                var newChannel = change.NewValue;

                 switch (newChannel?.Type)
                 {
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/LoungeBackgroundScreen.cs b/osu.Game/Screens/OnlinePlay/Lounge/LoungeBackgroundScreen.cs
index 52a902f5da..bef99f3737 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/LoungeBackgroundScreen.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/LoungeBackgroundScreen.cs
@@ -13,7 +13,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge
 {
     public class LoungeBackgroundScreen : OnlinePlayBackgroundScreen
     {
-        public readonly Bindable<Room> SelectedRoom = new Bindable<Room>();
+        public readonly Bindable<Room?> SelectedRoom = new Bindable<Room?>();
         private readonly BindableList<PlaylistItem> playlist = new BindableList<PlaylistItem>();

         public LoungeBackgroundScreen()
@@ -22,7 +22,7 @@ public LoungeBackgroundScreen()
             playlist.BindCollectionChanged((_, __) => PlaylistItem = playlist.GetCurrentItem());
         }

-        private void onSelectedRoomChanged(ValueChangedEvent<Room> room)
+        private void onSelectedRoomChanged(ValueChangedEvent<Room?> room)
         {
             if (room.OldValue != null)
                 playlist.UnbindFrom(room.OldValue.Playlist);
diff --git a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
index 1662ca399f..bcb7266338 100644
--- a/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
+++ b/osu.Game/Screens/Play/PlayerSettings/BeatmapOffsetControl.cs
@@ -29,7 +29,7 @@ namespace osu.Game.Screens.Play.PlayerSettings
 {
     public class BeatmapOffsetControl : CompositeDrawable
     {
-        public Bindable<ScoreInfo> ReferenceScore { get; } = new Bindable<ScoreInfo>();
+        public Bindable<ScoreInfo?> ReferenceScore { get; } = new Bindable<ScoreInfo?>();

         public BindableDouble Current { get; } = new BindableDouble
         {
@@ -180,7 +180,7 @@ void updateOffset()
             }
         }

-        private void scoreChanged(ValueChangedEvent<ScoreInfo> score)
+        private void scoreChanged(ValueChangedEvent<ScoreInfo?> score)
         {
             referenceScoreContainer.Clear();

As I concerned, it's hard to identify whether Bindable<T> or Bindable<T?> is correct. I also searched for the references of IBindable<T>.Value, and see most of them not checking for nulls. This also makes it painful to annotate Value as always-nullable.

smoogipoo · 2022-06-06T03:24:45Z

osu-framework.sln.DotSettings

@@ -58,6 +58,7 @@
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=CollectionNeverQueried_002ELocal/@EntryIndexedValue">HINT</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=CommentTypo/@EntryIndexedValue">HINT</s:String>
 	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=CompareOfFloatsByEqualityOperator/@EntryIndexedValue">HINT</s:String>
+	<s:String x:Key="/Default/CodeInspection/Highlighting/InspectionSeverities/=ConditionalAccessQualifierIsNonNullableAccordingToAPIContract/@EntryIndexedValue">HINT</s:String>


As I mentioned in #5207 (comment), we definitely do not want this. Use the new extensions if needed.

smoogipoo · 2022-06-06T03:30:27Z

osu.Framework/Bindables/Bindable.cs

        {
        }

        /// <summary>
        /// Creates a new bindable instance initialised with a default value.
        /// </summary>
        /// <param name="defaultValue">The initial and default value for this bindable.</param>
-        public Bindable(T defaultValue = default)
+        /// <remarks>Consider to pass a default value for non-nullable <typeparamref name="T"/>.</remarks>


Suggested change

/// <remarks>Consider to pass a default value for non-nullable <typeparamref name="T"/>.</remarks>

/// <remarks>Consider passing a default value for non-nullable <typeparamref name="T"/>.</remarks>

smoogipoo · 2022-06-06T03:54:47Z

osu.Framework/Bindables/Bindable.cs

+            // It lacks a way to represent "warn if called with non-nullable T".
+            // Not verifying to avoid breaking tons of existing usages.


Probably just remove this comment and the derived ctor (BindableWithCurrent, etc), as they read bad.

smoogipoo · 2022-06-06T03:55:43Z

osu.Framework/Bindables/Bindable.cs

@@ -359,8 +364,7 @@ public void UnbindBindings()

        internal virtual void UnbindAllInternal()
        {
-            if (isLeased)
-                leasedBindable.Return();
+            leasedBindable?.Return();


I'd probably prefer:

if (isLeased) { Debug.Assert(leasedBindable != null); leasedBindable.Return(); }

Or maybe leasedBindable.AsNonNull().Return() also works.

andy840119 · 2022-06-29T07:57:52Z

osu.Framework/Bindables/AggregateBindable.cs

+#nullable enable
+


Seems nullable enable can be removed after #5241 ?

Yep, all the enables should go away and disables be introduced as needed.

smoogipoo · 2022-06-29T08:01:45Z

@huoyaoyuan Are you interested in continuing this PR and applying the reviews above, or should @andy840119 try on his own?

andy840119 · 2022-06-29T09:05:06Z

I think @huoyaoyuan's commits are good enough.
I guess i will based in this PR if he's not working on this PR anymore.
And i maybe not working on this part that fast
Just notice that Bindable<T> might need to re-write as Bindable<T?> in osu side for prevent warning. I need to make a check about this.

huoyaoyuan · 2022-06-29T14:50:00Z

@smoogipoo I'm still interested, but I didn't have time to think about the design question here.

A Roslyn analyser for this would be quite simple to craft, and I'll do it myself provided the time.

Just to make sure we're on the same page, I would require cases like this to provide a parameter.

So the conclusion is to depend on a custom analyser right? I'll update this PR.

This reverts commit 3e88848.

smoogipoo · 2022-06-30T03:43:41Z

So the conclusion is to depend on a custom analyser right? I'll update this PR.

This PR can happen without an analyzer (as you have it with the todo is fine).

huoyaoyuan · 2022-06-30T04:03:59Z

CodeFactor is complaining about file I don't touch.

huoyaoyuan · 2022-07-01T06:09:28Z

Mention me if there is still any issue remaining. I'm a little busy to track a lot of things these days.

osu.Framework/Localisation/ILocalisedBindableString.cs

peppy · 2022-07-01T07:29:16Z

osu.Framework/Bindables/IHasDescription.cs

@@ -13,6 +11,6 @@ public interface IHasDescription
        /// <summary>
        /// The description for this object.
        /// </summary>
-        string Description { get; }
+        string? Description { get; }


I think we should use string.Empty rather than allow nullable, not sure though.

osu.Framework/Bindables/Bindable.cs

osu.Framework/Bindables/BindableWithCurrent.cs

smoogipoo

Rest looks pretty good to me. Will have to see how this works with the osu! repo before merge.

smoogipoo · 2022-07-04T05:27:19Z

osu.Framework/Bindables/Bindable.cs

+            // Deserialize returns null for json literal "null".
+            var result = serializer.Deserialize<T>(reader);
+            Debug.Assert(result != null);
+            Value = result;


I assume this is for a case like Bindable<int?>, right? In which case, if it returns null then I don't think this should assert. Probably use .AsNonNull() instead (basically just a null-forgiving now, no longer asserts internally).

The last change was by @frenzibyte
The assert should be only valid when T is non-nullable, which is not detectable at all in runtime.

Also AsNonNull can't be used for non-constrained generic types, we might want to apply what was proposed in discord to get it working correctly with no constraints.

Deserialization is a well-known hole of nullable annotations.
Here null forgiving operator should be the only option. It means we are bypassing any check because no check can be done.

Note for you: [return: NotNull] is no longer needed at all since C# 9. ? can be used on unconstrained type parameter.
So is there any decision here? I can't find anything valid other than !.

Wait for #5296 then use .AsNonNull().

@smoogipoo I've already updated this. Is there still any issue remaining?

huoyaoyuan · 2023-05-21T10:29:21Z

@peppy What do you think about this PR? Should I revive this or redo a new one?

peppy · 2023-05-25T09:57:39Z

@peppy What do you think about this PR? Should I revive this or redo a new one?

If you can resolve the conflicts, I think it's still in a state we could take another look at it. I have forgotten what state of review this was in, but on a quick check it looks like it was basically waiting for tooling fixes for NRT, so maybe there's hope still.

bdach · 2023-05-27T14:31:54Z

Code quality is failing.
I will reiterate what I already said above that this pull should be bundled with a preview of game-side changes that will follow after this pull. Over the last year we have been progressively enabling nullability on more and more files, so I find it unlikely that there will be no changes required.

huoyaoyuan · 2023-05-27T14:35:07Z

Code quality is failing.

In tests it's explicitly testing exception thrown with null input. That's the reason why .NET runtime projects don't turn on NRT in their test projects. We have #nullable disable there but Resharper is still analyzing them.

huoyaoyuan · 2023-05-27T17:06:21Z

The game side change is at ppy/osu#23680.

huoyaoyuan · 2024-11-27T13:46:32Z

osu-framework/osu.Framework.Tests/Bindables/AggregateBindableTest.cs

Line 53 in c274d81

    
           var aggregate = new AggregateBindable<BoxedInt>((a, b) => new BoxedInt((a?.Value ?? 0) + (b?.Value ?? 0)));

This line is really causing troubles:

The initial null value in constructor is currently suppressed. However, InspectCode is too strict about being conservative around nulls. Does there need an AsNullable extension method to explicitly state this?

frenzibyte · 2024-11-29T07:24:52Z

osu.Framework/Bindables/Bindable.cs

+            // TODO: add a custom analyser warning about no default value provided for non-nullable T
+            // remember to also check for derived class constructors


I see this TODO as mandatory before this PR can be merged. The implications of this can go as far as to end up merging PRs that can nullref in release builds because v.OldValue/v.NewValue usages were promised to be not null while in reality it is, due to the forgiving we're doing here.

I noticed there were previous discussions above leading to having the analyzer as follow-up effort, but I'm really not sure about that. @ppy/team-client can I have your opinions on this matter? am I the only one who thinks this cannot be merged as-is?

frenzibyte · 2024-11-29T08:05:01Z

osu.Framework/Bindables/Bindable.cs

        void ISerializableBindable.DeserializeFrom(JsonReader reader, JsonSerializer serializer)
        {
-            Value = serializer.Deserialize<T>(reader);
+            // Deserialize returns null for json literal "null".
+            // The nullability of type parameter T is unavailable here, so we can't do any validation.
+            Value = serializer.Deserialize<T>(reader).AsNonNull();
        }


This is a painful one to swallow, but it doesn't look like there's anything we can do about it.

frenzibyte · 2024-11-29T08:14:14Z

osu.Framework/Bindables/BindableList.cs

+        object? IList.this[int index]
        {
            get => this[index];
-            set => this[index] = (T)value;
+            set => this[index] = (T)value.AsNonNull();
        }

-        int IList.Add(object value)
+        int IList.Add(object? value)
        {
-            Add((T)value);
+            Add((T)value.AsNonNull());
            return Count - 1;
        }


I'm tempted to say we should just drop IList support if having it makes us sacrifice nullability rules completely. We can replace it with ICollection to keep support for the only usage of this interface, which is the Assert.Contains lines in BindableListTest. Other than that, I don't see any build failure on both ppy/osu-framework and ppy/osu.

Some of the code are really ancient from 3 years or even 5 years ago. I need to catch up about new usages.

frenzibyte · 2024-11-29T08:22:41Z

osu.Framework/Bindables/IBindableWithCurrent.cs

        public static IBindableWithCurrent<T> Create()
        {
            if (Validation.IsSupportedBindableNumberType<T>())
-                return (IBindableWithCurrent<T>)Activator.CreateInstance(typeof(BindableNumberWithCurrent<>).MakeGenericType(typeof(T)), default(T));
+                return (IBindableWithCurrent<T>)Activator.CreateInstance(typeof(BindableNumberWithCurrent<>).MakeGenericType(typeof(T)), default(T)).AsNonNull();

            return new BindableWithCurrent<T>();
        }


I...think we can just remove this altogether for now, it's not used anywhere, and having it be a factory method that can return bindables with null-but-we-dont-know value is not worth it.

frenzibyte · 2024-11-29T08:26:59Z

osu.Framework/Bindables/RangeConstrainedBindable.cs

@@ -64,7 +62,7 @@ public override T Value
        public bool HasDefinedRange => !EqualityComparer<T>.Default.Equals(MinValue, DefaultMinValue) ||
                                       !EqualityComparer<T>.Default.Equals(MaxValue, DefaultMaxValue);

-        protected RangeConstrainedBindable(T defaultValue = default)
+        protected RangeConstrainedBindable(T defaultValue = default!)


For this one you can just add a constraint to T to conform to struct, we don't have any non-struct usages of this and it doesn't make sense anyway.

Actually I planned to add more generic math constraint in the following. I'm supporting to add struct constraint.

frenzibyte · 2024-11-29T09:22:54Z

osu.Framework.Tests/Visual/Platform/FrameworkConfigVisualiser.cs

@@ -59,6 +59,6 @@ protected override void LoadComplete()
            }));
        }

-        private void updateText() => valueText.Text = bindable.ToString() ?? "<null>";
+        private void updateText() => valueText.Text = bindable?.ToString() ?? "<null>";


This should probably be rewritten to:

private void updateText() => valueText.Text = bindable.Value == null ? "<null>" : bindable.ToString();

Fixing the inspection error caught in this PR and making sense of the null fallback operator.

huoyaoyuan added 6 commits April 14, 2022 12:06

Enable NRT for Bindable

7191799

Resolve and add comments for constructor and deserialization.

3c3f9d7

Nullable for bindable list

1028d75

Enable nullable for other bindables

53abe18

Enable nullable for LocalisableBindableString

6650687

Disable aggressive warning about nullable

3e88848

pull-request-size bot added the size/L label Apr 14, 2022

bdach added the type:code-quality label Apr 16, 2022

bdach reviewed Apr 16, 2022

View reviewed changes

Apply suggestion from code review

fe5b8b6

Co-authored-by: Bartłomiej Dach <[email protected]>

huoyaoyuan mentioned this pull request May 27, 2022

Add IsNull()/IsNotNull() helper extensions #5207

Merged

smoogipoo requested changes Jun 6, 2022

View reviewed changes

andy840119 reviewed Jun 29, 2022

View reviewed changes

huoyaoyuan added 5 commits June 29, 2022 23:08

Merge branch 'master'

8e37160

Remove unnecessary #nullable for bindables

6ada9f5

Revert "Disable aggressive warning about nullable"

abd2caa

This reverts commit 3e88848.

Mark OnMixerChanged as nullable based on usage analysis

706cfe7

Update comments from suggestion

8f7fb1b

peppy reviewed Jul 1, 2022

View reviewed changes

huoyaoyuan and others added 3 commits July 2, 2022 12:52

Update more comments based on code review

7b1594f

Replace null-forgiving operator with AsNonNull

5a40906

Make description to be non-nullable

36a0f6e

smoogipoo requested changes Jul 4, 2022

View reviewed changes

huoyaoyuan added 2 commits July 7, 2022 15:30

Merge branch 'master' into bindable-nullability

b5becda

Use AsNonNull and add comment for explaination

56de9b4

huoyaoyuan force-pushed the bindable-nullability branch from 3af9254 to 56de9b4 Compare July 7, 2022 07:38

smoogipoo mentioned this pull request Jul 7, 2022

Change AsNonNull to NotNull return #5298

Merged

Merge branch 'master' into bindable-nullability

67ece5a

huoyaoyuan added 3 commits May 27, 2023 21:38

Merge branch 'master' into bindable-nullability

132c64d

Update nullable annotation for new members

0045365

Use MemberNotNullWhen to remove workaround for isLeased

db7c54a

huoyaoyuan mentioned this pull request May 27, 2023

Changes for nullability of bindables ppy/osu#23680

Draft

huoyaoyuan added 3 commits November 27, 2024 20:46

Merge branch 'master'

6804bda

Update annotations with latest usages

9c9b8ad

Update InspectCode warnings

62deab7

huoyaoyuan force-pushed the bindable-nullability branch from 7e4284e to 62deab7 Compare November 27, 2024 13:39

frenzibyte self-requested a review November 29, 2024 06:54

frenzibyte reviewed Nov 29, 2024

View reviewed changes

		// It lacks a way to represent "warn if called with non-nullable T".
		// Not verifying to avoid breaking tons of existing usages.

	/// <remarks>Consider to pass a default value for non-nullable <typeparamref name="T"/>.</remarks>
	/// <remarks>Consider passing a default value for non-nullable <typeparamref name="T"/>.</remarks>

		// TODO: add a custom analyser warning about no default value provided for non-nullable T
		// remember to also check for derived class constructors

Nullability annotations for bindables #5099

Are you sure you want to change the base?

Nullability annotations for bindables #5099

Conversation

huoyaoyuan commented Apr 14, 2022

Risks

bdach commented Apr 16, 2022

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

smoogipoo Jun 7, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

huoyaoyuan commented Apr 30, 2022

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

smoogipoo commented Jun 29, 2022

andy840119 commented Jun 29, 2022 • edited Loading

huoyaoyuan commented Jun 29, 2022

smoogipoo commented Jun 30, 2022 • edited Loading

huoyaoyuan commented Jun 30, 2022

huoyaoyuan commented Jul 1, 2022

Choose a reason for hiding this comment

smoogipoo left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

huoyaoyuan Jul 4, 2022 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

huoyaoyuan commented May 21, 2023

peppy commented May 25, 2023

bdach commented May 27, 2023

huoyaoyuan commented May 27, 2023

huoyaoyuan commented May 27, 2023

huoyaoyuan commented Nov 27, 2024

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

smoogipoo Jun 7, 2022 •

edited

Loading

andy840119 commented Jun 29, 2022 •

edited

Loading

smoogipoo commented Jun 30, 2022 •

edited

Loading

huoyaoyuan Jul 4, 2022 •

edited

Loading