Add shared cursorInfo infrastructure and forEach-to-forIn code action by MoonMao42 · Pull Request #2588 · swiftlang/sourcekit-lsp

MoonMao42 · 2026-04-01T03:58:09Z

Closes #2584
Closes #2509

Adds SharedCursorInfo so code action providers can share a single cursorInfo request. SyntaxCodeActionProvider.codeActions(in:) is now async, and the scope object (renamed to CodeActionScope) is created once in codeAction() and passed to all retrieve methods.

Also adds a code action to convert .forEach to for-in loops, as the first provider that uses this.

Before:

names.forEach { name in
  print(name)
}

After:

for name in names {
  print(name)
}

Only handles closures with explicit named parameters ($0 shorthand is not supported).

rintaro

Looks pretty good already!

rintaro · 2026-04-01T15:01:43Z

+/// Lazy, shared cache for a single `cursorInfo` request across concurrent code action providers.
+///
+/// The first call to `get()` triggers the sourcekitd request; subsequent calls await the same `Task`.
+actor SharedCursorInfo {


I think this whole actor can be generalized as something like:

actor LazyTask<Success: Sendable> { private let operation: @Sendable () async throws -> Success init(_ operation: @escaping @Sendable () async throws -> Success) { self.operation = operation } private lazy var task: Task<Success, any Error> = Task { try await operation() } var value: Success { get async throws { try await task.value } } }

Maybe we already have something like it?

rintaro · 2026-04-01T15:57:44Z

+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors


Suggested change

// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors

// Copyright (c) 2014 - 2026 Apple Inc. and the Swift project authors

rintaro · 2026-04-01T16:29:02Z

+    return nil
+  }
+
+  let visitor = ForEachCallVisitor(rangeToMatch: scope.range)


Is SyntaxVisitor really relevant? For example, for:

1️⃣func test() { 2️⃣foo.bar.3️⃣forEach4️⃣ { item in print(item) }5️⃣ }6️⃣

I think we should only offer the code action when the curosr/selection is 2️⃣..<4️⃣, 2️⃣..<5️⃣, 3️⃣..<3️⃣, 3️⃣..<4️⃣, and 3️⃣..<5️⃣.
I think using a visitor and returning .visitChildren for every failure case makes it available for 1️⃣..<6️⃣ or even for the entire source file.
Please add test cases as needed.

rintaro · 2026-04-01T18:13:54Z

+      return []
+    }
+
+    guard !hasTryOrAwait(match.closure) else {


Could you explain what is a case we can't convert it to for-in?

I understand having try? outside the forEach call expression is not easy:

try? foo.forEach { ...; try ...; }

to:

do { for item in foo { ...; try ...; } } catch { /*ignore*/ }

But I'm not sure having try in the closure body prevents anything.

rintaro · 2026-04-01T21:10:26Z

+  }
+
+  // Reject if parameter is shorthand $0 syntax
+  if param.firstName.text == "$0" {


I don't think this handles anonymous closure parameters. $0 does not appear in the closure parameter syntax tree.

It would be great this also rewrites $0. I.e. rewrite

foo.forEach { print($0) }

with

for element in foo { print(element) }

It's not super obvious whether we can use element though, we should check if it's not already used in the body.

rintaro · 2026-04-01T21:19:57Z

+  }
+
+  override func visit(_ node: FunctionDeclSyntax) -> DeclSyntax {
+    DeclSyntax(node)


I don't think we should dig into any non-StmtSyntax.
Are there any cases where return in an expression or decl escapes the surrounding function scope?

I don't see you addressed this? Also applies to other visitors/rewriters. Please avoid dig into unnecessary nodes.

Addressed — all three visitor/rewriter classes (ClosureEligibilityVisitor, ReturnToContinueRewriter, DollarZeroRewriter) now consistently skip the same five scope-introducing constructs: FunctionDeclSyntax, InitializerDeclSyntax, DeinitializerDeclSyntax, ClosureExprSyntax, AccessorBlockSyntax.

rintaro · 2026-04-01T21:29:56Z

Please add this file and SharedCursorInfo.swift to https://github.com/swiftlang/sourcekit-lsp/blob/main/Sources/SwiftLanguageService/CMakeLists.txt

rintaro · 2026-04-01T21:31:45Z

+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors


Suggested change

// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors

// Copyright (c) 2014 - 2026 Apple Inc. and the Swift project authors

rintaro · 2026-04-01T21:42:05Z

+    return nil
+  }
+
+  guard let parameters = signature.parameterClause?.as(ClosureParameterClauseSyntax.self) else {


What about ClosureShortParameterSyntax? Ideally the conversion should be:
foo.forEach { item in ... } -> for item in foo { ... }
foo.forEach { (item) in ... } -> for item in foo { ... }
foo.forEach { (item: Ty) in ... } -> for item: Ty in foo { ... }

rintaro · 2026-04-01T21:58:45Z

+    }
+
    let codeActionCapabilities = capabilityRegistry.clientCapabilities.textDocument?.codeAction
-    let codeActions = try await retrieveCodeActions(req, providers: providers)


func retrieveCodeActions(_:providers:) below is now unused.

rintaro · 2026-04-01T22:02:49Z

+
+    if wantedActionKinds == nil {
+      allCodeActions += await retrieveSyntaxCodeActions(scope)
+    }


I think retrieveSyntaxCodeActions was added even if wantedActionKinds exist. Am I missing something?

rintaro · 2026-04-01T22:21:02Z

+/// A lazily-evaluated, shared async value that is computed at most once.
+///
+/// The first access triggers the operation; subsequent accesses await the same `Task`.
+actor LazyValue<Success: Sendable> {


Could you use a different name?
We already have LazyValue with different semantics here https://github.com/swiftlang/sourcekit-lsp/blob/main/Sources/SwiftExtensions/LazyValue.swift

MoonMao42 · 2026-04-04T04:49:13Z

Done, thanks for the review.

rintaro · 2026-04-06T08:03:32Z

+  }
+
+  /// Returns cursorInfo at the position of the given syntax node.
+  func cursorInfo(at absolutePosition: AbsolutePosition) async throws -> CursorInfo? {


Ah sorry I didn't think about what information is in the cursor-info result when I was suggesting the ranges to offer actions.

We'd like to avoid requesting non-shared cursorInfo in textDocument/codeAction request. Could you remove this? And I think it's okay for now to suggest this action only when the cursor is on forEach.

I.e. for

1️⃣func test() { let array = [1, 2, 3] 2️⃣array.reversed().3️⃣forEach4️⃣ { item in print(item) }5️⃣ }6️⃣

The action is active only for 3️⃣..<3️⃣ and 3️⃣..<4️⃣.

Makes sense — the action now activates only when the cursor/selection is exactly on the forEach token, so shared cursorInfo at the request position works.

rintaro · 2026-04-06T08:26:37Z

+
+  // Walk up from the innermost node to find a forEach call expression,
+  // stopping at function/closure boundaries to avoid matching distant calls.
+  guard let callExpr = node.findParentOfSelf(


If it's only active at forEach, the check can be something like:

guard let token = node.as(TokenSyntax.self), token.text = "forEach" let memberName = token.parent?.as(DeclReferenceExprSyntax.self), let memberAccessExpr = member.parent?.as(MemberAccessExprSyntax.self), memberAccessExpr.declName.id == memberName.id, let callExpr = memberAccessExpr.parent?.as(FunctionCallExprSyntax.self), callExpr.calledExpression.id == memberAccessExpr, else { return nil } let closure: ClosureExprSyntax? ...

Done — replaced with selectedForEachToken(in:) that validates directly against the request range positions.

rintaro · 2026-04-06T08:26:48Z

+  return Match(
+    callExpr: callExpr,
+    memberAccess: memberAccess,
+    collection: collection,


forEach(_:) is available on Sequence, so could you name this sequence instead of collection?

rintaro · 2026-04-06T08:32:06Z

+    }
+
+    let forEachPosition = match.memberAccess.declName.baseName.positionAfterSkippingLeadingTrivia
+    guard let info = try? await scope.cursorInfo(at: forEachPosition),


And this can be scope.cursorInfo()

rintaro · 2026-04-06T08:34:37Z

+    guard !hasReturnWithValue(match.closure) else {
+      return []
+    }
+
+    guard !hasAwait(match.closure) else {
+      return []
+    }


Could you make a single function/visitor checking both? So we can check the eligibility in single pass.

rintaro · 2026-04-06T08:47:15Z

+private func extractParameter(from closure: ClosureExprSyntax) -> ClosureParam? {
+  guard let signature = closure.signature else {
+    // No signature → anonymous $0 usage.
+    let name = generateUniqueName(avoiding: collectIdentifiers(in: closure.statements))


I don't think we need to separate function for this.
Also, could you avoid inserting every identifier in the Set, we're only interested in identifiers starting with element

Done — containsIdentifier(named:in:) now checks on demand instead of collecting all names.

rintaro · 2026-04-06T08:54:46Z

+  }
+
+  override func visit(_ node: FunctionDeclSyntax) -> DeclSyntax {
+    DeclSyntax(node)


I don't see you addressed this? Also applies to other visitors/rewriters. Please avoid dig into unnecessary nodes.

rintaro

It's getting close!
Just a few nit-picky edge case handling suggestions.

rintaro · 2026-04-09T04:39:27Z

+    guard node.expression == nil else {
+      return StmtSyntax(node)
+    }
+    return StmtSyntax(ContinueStmtSyntax())


So I realized this is not enough for cases like

items.forEach { item in for elem in item.elements { if condition(elem) { return } } // ... }

In this case, we need a label on the rewritten for-in:

ITEM: for item in items { for elem in item.elements { if condition(elem) { continue ITEM } } // ... }

That said, I'm fine with ignoring such cases for this PR. But in that case, could you add FIXME and file an issue for that?

rintaro · 2026-04-09T04:42:17Z

+  override func visit(_ node: InitializerDeclSyntax) -> SyntaxVisitorContinueKind { .skipChildren }
+  override func visit(_ node: DeinitializerDeclSyntax) -> SyntaxVisitorContinueKind { .skipChildren }
+  override func visit(_ node: ClosureExprSyntax) -> SyntaxVisitorContinueKind { .skipChildren }
+  override func visit(_ node: AccessorBlockSyntax) -> SyntaxVisitorContinueKind { .skipChildren }


Any type declarations too. i.e. struct, class, enum, etc.

rintaro · 2026-04-09T04:53:35Z

+}
+
+private func extractParameter(from closure: ClosureExprSyntax) -> ClosureParam? {
+  guard let signature = closure.signature else {


Rare edge case:

arr.forEach { [] in print($0) }

In this case signature is non-nil.
Even more edge case:

arr.forEach { [foo = bar] in print($0, foo) }

I guess we should rewrite this like

do { let foo = bar for element in arr { print(element, foo) } }

But it's too much effort.
I'm fine with just rejecting (not offering the action) for closures with capture list.

rintaro · 2026-04-09T04:56:54Z

+  guard let token = selectedForEachToken(in: scope),
+        token.text == "forEach",


I'm not sure this is what swift-format suggests. Could you run swift format -i -r . at the package top-level directory? Otherwise the test will fail.

rintaro · 2026-04-09T19:42:03Z

+
+/// Matches only when the cursor/selection is on the `forEach` token.
+private func findForEachCall(in scope: CodeActionScope) -> Match? {
+  guard let token = selectedForEachToken(in: scope),


Does scope.innermostNodeContainingRange not work?

tokenForRefactoring shifts the cursor to the previous token at exact token boundaries, so innermostNodeContainingRange resolves to . instead of forEach when the cursor is at the start of forEach. selectedForEachToken bypasses this by matching against the raw request position.

rintaro · 2026-04-11T22:30:55Z

@swift-ci Please test

rintaro · 2026-04-13T21:29:10Z

@MoonMao42 Could you rebase on the current main and fix the build issue?
Also macOS failure indicates the formatting is still off. Try swift format -i -r . again right before pushing.

rintaro · 2026-04-13T21:32:28Z

+    async let refactorActions = wantActionKind(.refactor) ? try await retrieveRefactorCodeActions(scope) : []
+    async let quickFixActions = wantActionKind(.quickFix) ? try await retrieveQuickFixCodeActions(scope) : []
+    async let unusedImportActions = wantActionKind(.sourceOrganizeImports)
+      ? try await retrieveRemoveUnusedImportsCodeAction(scope) : []


Ah, I think try await shouldn't be here.

- Generalize SharedCursorInfo into a reusable LazyValue<Success> actor - Extract result tuple into CursorInfoResponse struct - Make sharedCursorInfo non-optional in CodeActionScope - Remove unnecessary `package` access level and error swallowing - Bake additionalParameters into the init closure instead of get() - Remove infrastructure tests that don't verify meaningful behavior

- Replace downward SyntaxVisitor with upward findParentOfSelf walk - Handle all closure parameter forms (simpleInput, parameterClause) - Support $0 shorthand with DollarZeroRewriter (skips nested closures) - Allow try in closure body (forEach is rethrows) - Request cursorInfo at forEach position, not cursor position - Add cursorInfoProvider to CodeActionScope for positional lookups - Narrow return/continue rewriting to skip accessor boundaries - Rename LazyValue to AsyncLazy, delete unused retrieveCodeActions - Add CMakeLists.txt entries, fix copyright years - Rewrite tests using SwiftPMTestProject for proper stdlib resolution

…e and await walk(closure) triggers visit(ClosureExprSyntax) on the root node itself, which returns .skipChildren — making the visitor a no-op. Walk the closure's statements instead so the skip-closure logic only applies to nested closures.

- Use BasicFormat to produce correctly indented for-in output - Trim collection expression trivia for clean output - Tests now verify exact replacement text instead of just action presence - Add selection range boundary tests - Add test for closure body cursor position (should not offer action) - Add test for nested $0 not being rewritten - Add test verifying bare return → continue in output

- Unify scope boundaries across all visitor/rewriter classes to skip FunctionDeclSyntax, InitializerDeclSyntax, DeinitializerDeclSyntax, ClosureExprSyntax, and AccessorBlockSyntax - Merge ReturnWithValueVisitor and AwaitVisitor into single-pass ClosureEligibilityVisitor - Replace findParentOfSelf with token-level matching via selectedForEachToken for precise cursor/selection validation - Rename collection to sequence - Simplify generateUniqueName to avoid collecting all identifiers - Remove cursorInfoProvider from CodeActionScope, use shared cursorInfo - Parallelize code action retrieval with async let

- Handle bare return in nested loops with labeled continue - Skip type declarations (struct, class, enum, etc.) in all visitors - Reject closures with capture lists - Add tests for labeled continue, capture list rejection - Apply swift-format

MoonMao42 · 2026-04-19T13:18:54Z

@rintaro It's OK?I format it.

rintaro · 2026-04-23T03:30:04Z

@swift-ci Please test

rintaro · 2026-04-23T06:22:10Z

[2026-04-23T05:43:05.440Z] /home/build-user/sourcekit-lsp/Sources/SwiftLanguageService/CodeActions/ConvertCommentToDocComment.swift:41:40: error: cannot find type 'SyntaxCodeActionScope' in scope
[2026-04-23T05:43:05.440Z] 39 |   static let title = "Convert Comment to Doc Comment"
[2026-04-23T05:43:05.440Z] 40 | 
[2026-04-23T05:43:05.440Z] 41 |   static func nodeToRefactor(in scope: SyntaxCodeActionScope) -> DeclSyntax? {
[2026-04-23T05:43:05.440Z]    |                                        `- error: cannot find type 'SyntaxCodeActionScope' in scope
[2026-04-23T05:43:05.440Z] 42 |     let cursorPosition = scope.snapshot.absolutePosition(of: scope.request.range.lowerBound)
[2026-04-23T05:43:05.440Z] 43 |     guard let token = scope.file.token(at: cursorPosition) else {
[2026-04-23T05:43:05.440Z] 
[2026-04-23T05:43:05.440Z] /home/build-user/sourcekit-lsp/Sources/SwiftLanguageService/CodeActions/ConvertCommentToDocComment.swift:56:62: error: cannot infer contextual base in reference to member 'sourceAccurate'
[2026-04-23T05:43:05.440Z] 54 |     else { return nil }
[2026-04-23T05:43:05.440Z] 55 | 
[2026-04-23T05:43:05.440Z] 56 |     guard let firstToken = declaration.firstToken(viewMode: .sourceAccurate),
[2026-04-23T05:43:05.440Z]    |                                                              `- error: cannot infer contextual base in reference to member 'sourceAccurate'
[2026-04-23T05:43:05.440Z] 57 |       firstToken.id == token.id
[2026-04-23T05:43:05.440Z] 58 |     else { return nil }

I think ConvertCommentToDocComment.swift was added after you opened this PR. Please run tests locally again and fix the issues.

MoonMao42 · 2026-04-24T03:02:34Z

[2026-04-23T05:43:05.440Z] /home/build-user/sourcekit-lsp/Sources/SwiftLanguageService/CodeActions/ConvertCommentToDocComment.swift:41:40: error: cannot find type 'SyntaxCodeActionScope' in scope
[2026-04-23T05:43:05.440Z] 39 |   static let title = "Convert Comment to Doc Comment"
[2026-04-23T05:43:05.440Z] 40 | 
[2026-04-23T05:43:05.440Z] 41 |   static func nodeToRefactor(in scope: SyntaxCodeActionScope) -> DeclSyntax? {
[2026-04-23T05:43:05.440Z]    |                                        `- error: cannot find type 'SyntaxCodeActionScope' in scope
[2026-04-23T05:43:05.440Z] 42 |     let cursorPosition = scope.snapshot.absolutePosition(of: scope.request.range.lowerBound)
[2026-04-23T05:43:05.440Z] 43 |     guard let token = scope.file.token(at: cursorPosition) else {
[2026-04-23T05:43:05.440Z] 
[2026-04-23T05:43:05.440Z] /home/build-user/sourcekit-lsp/Sources/SwiftLanguageService/CodeActions/ConvertCommentToDocComment.swift:56:62: error: cannot infer contextual base in reference to member 'sourceAccurate'
[2026-04-23T05:43:05.440Z] 54 |     else { return nil }
[2026-04-23T05:43:05.440Z] 55 | 
[2026-04-23T05:43:05.440Z] 56 |     guard let firstToken = declaration.firstToken(viewMode: .sourceAccurate),
[2026-04-23T05:43:05.440Z]    |                                                              `- error: cannot infer contextual base in reference to member 'sourceAccurate'
[2026-04-23T05:43:05.440Z] 57 |       firstToken.id == token.id
[2026-04-23T05:43:05.440Z] 58 |     else { return nil }

I think ConvertCommentToDocComment.swift was added after you opened this PR. Please run tests locally again and fix the issues.

All right.

rintaro · 2026-04-24T05:08:53Z

@swift-ci Please test

This reverts commit 52c8ab1.

rintaro · 2026-04-24T14:07:37Z

@swift-ci Please test

rintaro · 2026-04-24T18:07:36Z

@swift-ci Please test Windows

ahoppen · 2026-04-27T13:25:58Z

+    self.operation = operation
+  }
+
+  private lazy var task: Task<Success, any Error> = Task {


This task won’t get cancelled if the codeAction request is cancelled. Could you adopt cancellation here? We could eg. cancel the task if AsyncLazy gets reinitialized.

ahoppen · 2026-04-27T13:29:03Z

      }
+      return try await self.cursorInfo(
+        uri,
+        range,


Do we really want to execute the cursor info request at range? I just implemented something similar in #2622 and there eg. when you have

var x = 2

And you invoke the code action on var, then the code action to convert the stored property to a computed property is applicable but we need to run the cursor info at x to get the type of x to add a type annotation.

I think this should meet expectations.

We already request cursorInfo for range in retrieveRefactorCodeActions. The idea was to reuse that if it is sufficient for determining applicability. Otherwise, I don't think we should allow each code action provider to request arbitrary cursorInfo during textDocument/codeAction.

Refactor SharedCursorInfo to cache cursor info responses keyed by Range<Position> instead of computing a single value. This allows code action providers to request semantic information at the position that is most relevant for their specific refactoring. - Convert SharedCursorInfo from AsyncLazy<CursorInfoResponse> to a dictionary-backed actor keyed by Range<Position> - Add cursorInfo(at:) and cursorInfo(for:) helpers on CodeActionScope - Have ForEachToForInCodeAction query cursor info at the forEach token rather than the original request range

# Conflicts: # Sources/SwiftLanguageService/CMakeLists.txt # Sources/SwiftSyntaxCodeActions/ApplyDeMorganLaw.swift # Sources/SwiftSyntaxCodeActions/ConvertIfLetToGuard.swift # Sources/SwiftSyntaxCodeActions/ConvertIntegerLiteral.swift # Sources/SwiftSyntaxCodeActions/ForEachToForInCodeAction.swift # Sources/SwiftSyntaxCodeActions/PackageManifestEdits.swift # Sources/SwiftSyntaxCodeActions/SharedCursorInfo.swift # Sources/SwiftSyntaxCodeActions/SyntaxCodeActionProvider.swift # Sources/SwiftSyntaxCodeActions/SyntaxRefactoringCodeActionProvider.swift

MoonMao42 · 2026-05-15T12:18:54Z

@rintaro @ahoppen Maybe we should align on the cursorInfo direction here.I updated the conflict resolution to follow rintaro’s suggestion for this PR. That seems cheaper, and the behavior is easier to reason about. The cases that need cursorInfo at a different position seem like they should go through the structured approach in #2622, rather than having each syntactic code action issue its own cursorInfo request.

MoonMao42 requested review from ahoppen, hamishknight and rintaro as code owners April 1, 2026 03:58

rintaro reviewed Apr 1, 2026

View reviewed changes

rintaro reviewed Apr 6, 2026

View reviewed changes

rintaro reviewed Apr 9, 2026

View reviewed changes

rintaro reviewed Apr 13, 2026

View reviewed changes

MoonMao42 added 8 commits April 14, 2026 22:28

Add shared cursorInfo infrastructure and forEach-to-forIn code action

84e3d03

Address fourth round of review feedback

6b3eef4

- Handle bare return in nested loops with labeled continue - Skip type declarations (struct, class, enum, etc.) in all visitors - Reject closures with capture lists - Add tests for labeled continue, capture list rejection - Apply swift-format

Remove redundant try await from async let initializers and reformat

e31adb4

MoonMao42 force-pushed the shared-cursorinfo-pr branch from 5a20f1f to e31adb4 Compare April 14, 2026 14:31

Fix code action scope after main update

52c8ab1

MoonMao42 added 2 commits April 24, 2026 16:29

Revert "Fix code action scope after main update"

dd53596

This reverts commit 52c8ab1.

Fix comment code action scope type

7536d9c

Fix Windows build for forEach conversion

2c4fc12

ahoppen reviewed Apr 27, 2026

View reviewed changes

rintaro mentioned this pull request May 10, 2026

Add refactoring action to convert stored to computed properties #2622

Open

	// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
	// Copyright (c) 2014 - 2026 Apple Inc. and the Swift project authors

		guard let token = selectedForEachToken(in: scope),
		token.text == "forEach",

Conversation

MoonMao42 commented Apr 1, 2026

Uh oh!

rintaro left a comment

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

rintaro Apr 1, 2026 • 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!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

rintaro Apr 1, 2026 • 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!

rintaro Apr 1, 2026 • 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!

rintaro Apr 1, 2026 • 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!

rintaro Apr 1, 2026 • 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!

rintaro Apr 1, 2026 • 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!

MoonMao42 commented Apr 4, 2026

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!

Choose a reason for hiding this comment

Uh oh!

rintaro left a comment

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

rintaro Apr 1, 2026 •

edited

Loading

rintaro Apr 1, 2026 •

edited

Loading

rintaro Apr 1, 2026 •

edited

Loading

rintaro Apr 1, 2026 •

edited

Loading

rintaro Apr 1, 2026 •

edited

Loading

rintaro Apr 1, 2026 •

edited

Loading

MoonMao42 Apr 10, 2026 •

edited

Loading

MoonMao42 commented Apr 19, 2026 •

edited

Loading