Crash in Release builds when using `KFImage` extension modifiers that mutate `context` (`placeholder` / `cancelOnDisappear`)

[greatsk55]

Environment

• Kingfisher version: 8.5.0
• Swift version: 5.5
• Xcode version: 16.2
• Build configuration: Release (-O)

Summary

KFImage extension methods that mutate context via a var image = self; image.context = ...; return image pattern crash only in Release builds (does not reproduce in Debug). The crash appears tied to optimized builds and likely stems from unsafe in-place mutation of KFImage/its context, escaping closures + AnyView type-erasure, or optimizer-induced undefined behavior.

Steps to reproduce (minimal)

1. Add an extension on KFImage like the following and use it in a SwiftUI view:

extension KFImage {
  public func kfPlaceholder<P: View>(@ViewBuilder _ content: @escaping (Progress) -> P) -> Self {
      var image = self
      image.context.placeholder = { progress in AnyView(content(progress)) }
      return image
  }
  public func kfCancelOnDisappear(_ flag: Bool) -> Self {
      var image = self
      image.context.cancelOnDisappear = flag
      return image
  }
}

2. Build the app using Release configuration (Optimize for Speed) and run on device or TestFlight.
3. Use the modifiers above while loading images. The app crashes during view composition / image lifecycle.

Expected behavior

Modifiers should safely set placeholder/failure/cancel flags without crashing in Release builds.

Actual behavior

• Crash only in Release (optimized) builds.
• No crash in Debug builds.
• Removing the in-place mutation or delegating to the protocol-level API removes the crash.

Observed clues

• Crash is optimizer-dependent (Release-only).
• In-place mutation of self.context with var image = self is correlated with failure.
• Escaping ViewBuilder-based closures and AnyView used as placeholder are involved.
• Stack traces vary; crash often occurs when view is created/destroyed or closure executes.

Analysis — plausible causes

1. Unsafe in-place mutation / copy-on-write aliasing

   • KFImage is a View (value type). Mutating a nested context that may be a reference type or has COW semantics can create aliasing or use-after-free under -O optimizations.

2. Escaping closures + type-erasure lifetime

   • Storing an escaping closure that returns AnyView into internal context could violate lifetime assumptions when optimized.

3. Thread-safety / data race

   • If context is shared across copies or mutated on different threads, timing differences in Release can trigger races.

4. Compiler/optimizer bug

   • Complex interactions between value mutation, escaping closures, and SwiftUI may expose an optimizer bug only visible in Release.

Suggested fix (safe, minimal)

Remove the mutating KFImage helpers and provide non-mutating wrappers that delegate to the existing KFImageProtocol modifiers or return some View. This avoids in-place mutation of a value-type view.

Replace the problematic methods:

/// Sets a placeholder `View` that is displayed during the image loading, with a progress parameter as input.
    ///
    /// - Parameter content: A view that represents the placeholder.
    /// - Returns: A Kingfisher-compatible image view that includes the provided `content` as its placeholder.
    public func placeholder<P: View>(@ViewBuilder _ content: @escaping (Progress) -> P) -> Self {
        context.placeholder = { progress in
            return AnyView(content(progress))
        }
        return self
    }
    
    /// Sets a placeholder `View` that is displayed during the image loading.
    ///
    /// - Parameter content: A view that represents the placeholder.
    /// - Returns: A Kingfisher-compatible image view that includes the provided `content` as its placeholder.
    public func placeholder<P: View>(@ViewBuilder _ content: @escaping () -> P) -> Self {
        placeholder { _ in content() }
    }
    /// Enables canceling the download task associated with `self` when the view disappears.
    ///
    /// - Parameter flag: A boolean value indicating whether to cancel the task.
    /// - Returns: A Kingfisher-compatible image view that cancels the download task when it disappears.
    public func cancelOnDisappear(_ flag: Bool) -> Self {
        context.cancelOnDisappear = flag
        return self
    }

With non-mutating wrappers that call the protocol-level API:

extension KFImageProtocol {
  public func placeholder<P: View>(@ViewBuilder _ content: @escaping (Progress) -> P) -> some View {
    // Delegate to KFImageProtocol's safe modifier
    return self.placeholder { progress in AnyView(content(progress)) }
  }

  public func placeholder<P: View>(@ViewBuilder _ content: @escaping () -> P) -> some View {
    return kfPlaceholder { _ in content() }
  }

  public func cancelOnDisappear(_ flag: Bool) -> some View {
    return self.cancelOnDisappear(flag)
  }
}

Rationale

• Avoids mutating nested state on a value-type View.
• Returning some View avoids unsafe Self mutation semantics and plays better with optimizer/copy semantics.
• Consolidates behavior to the protocol-level API which already exists.

Additional recommendations

• If context is a reference type, consider copy-on-write semantics or making mutation thread-safe.
• Add a test that compiles and runs the relevant code path in Release optimization to detect regressions.
• Run Address/Thread/UB sanitizers in Release-like modes to reveal undefined behavior or data races.
• If possible, include crash logs / stack traces from Release runs to help triage.

Temporary workaround

Use the KFImageProtocol modifiers directly (non-mutating), or remove var image = self mutation. Keep placeholder/failure views supplied at call site via the protocol API.

Request

If maintainers want to triage further, please advise which debug artifacts are most helpful (symbolicated crash log, release-mode sample project). I can prepare a minimal reproducible sample or a PR implementing the non-mutating wrappers and tests.

Labels suggestion

bug, release-only, swift-optimizer, help wanted

[onevcat]

Thank you for reporting this issue. Could you provide more details?

1. Where did you add the extension? I tried adding it to a demo app target and received the error: 'placeholder' is inaccessible due to 'internal' protection level. This makes sense because the placeholder setter is internal and cannot be extended in a different target. However, when I added the extension to the Kingfisher framework target, I could not reproduce the issue, even when building the app target for release.

2. This might be related to your Xcode or iOS version. Please try using the latest Xcode and iOS versions. If the issue does not occur with the latest versions (26.1), I will try downloading older Xcode versions to see if I can reproduce it there.