feat(render): complete opacity effects

Author: Kyle-Ye

Sources/OpenSwiftUICore/Render/RendererEffect/OpacityEffect.swift

@@ -3,11 +3,11 @@
 //  OpenSwiftUICore
 //
 //  Audited for 6.5.4
-//  Status: WIP
+//  Status: Complete
 //  ID: 34FFA2034B9AD53E0463E3971529C5A1 (SwiftUICore)
 
 package import OpenCoreGraphicsShims
-import OpenAttributeGraphShims
+package import OpenAttributeGraphShims
 
 // MARK: - _OpacityEffect
 
@@ -55,6 +55,11 @@ public struct _OpacityEffect: RendererEffect, Equatable {
                     )
                 )
             }
+            inputs.opacityAccessibilityProvider.makeOpacity(
+                effect: modifier.value,
+                inputs: inputs,
+                outputs: &outputs
+            )
             return outputs
         }
     }
@@ -93,7 +98,7 @@ extension View {
     ///
     /// ![Two overlaid rectangles, where the topmost has its opacity set to 50%,
     /// which allows the occluded portion of the bottom rectangle to be
-    /// visible.](OpenSwiftUI-View-opacity.png)
+    /// visible.](OpenSwiftUI-View-opacity)
     ///
     /// - Parameter opacity: A value between 0 (fully transparent) and 1 (fully
     ///   opaque).
@@ -215,17 +220,141 @@ extension _OpacityEffect: ProtobufMessage {
 
 // MARK: - ShapeStyle + _OpacityShapeStyle
 
-// TODO: _OpacityShapeStyle
+@available(OpenSwiftUI_v4_0, *)
+extension ShapeStyle where Self == AnyShapeStyle {
+    /// Returns a new style based on the current style that multiplies
+    /// by `opacity` when drawing.
+    ///
+    /// In most contexts the current style is the foreground but e.g.
+    /// when setting the value of the background style, that becomes
+    /// the current implicit style.
+    ///
+    /// For example, a circle filled with the current foreground
+    /// style at fifty-percent opacity:
+    ///
+    ///     Circle().fill(.opacity(0.5))
+    ///
+    @_alwaysEmitIntoClient
+    public static func opacity(_ opacity: Double) -> some ShapeStyle {
+        _OpacityShapeStyle(style: _ImplicitShapeStyle(), opacity: Float(opacity))
+    }
+}
+
+// MARK: - _OpacityShapeStyle
+
+@available(OpenSwiftUI_v3_0, *)
+@frozen
+public struct _OpacityShapeStyle<Style>: ShapeStyle, PrimitiveShapeStyle where Style: ShapeStyle {
+    public var style: Style
+
+    public var opacity: Float
+
+    @inlinable
+    public init(style: Style, opacity: Float) {
+        self.style = style
+        self.opacity = opacity
+    }
+
+    public func _apply(to shape: inout _ShapeStyle_Shape) {
+        guard opacity != 1 else {
+            style._apply(to: &shape)
+            return
+        }
+        switch shape.operation {
+        case .prepareText:
+            shape.result = .preparedText(.foregroundKeyColor)
+        case let .resolveStyle(name, levels):
+            style._apply(to: &shape)
+            shape.stylePack.modify(name: name, levels: levels) { style in
+                style.applyOpacity(opacity)
+            }
+        case .fallbackColor:
+            style._apply(to: &shape)
+            if case let .color(color) = shape.result {
+                shape.result = .color(color.opacity(Double(opacity)))
+            }
+        case .copyStyle:
+            style.mapCopiedStyle(in: &shape) { style in
+                _OpacityShapeStyle<AnyShapeStyle>(style: style, opacity: opacity)
+            }
+        case .modifyBackground, .multiLevel:
+            style._apply(to: &shape)
+        case .primaryStyle:
+            break
+        }
+    }
 
-// TODO: _OpacitiesShapeStyle
+    public static func _apply(to type: inout _ShapeStyle_ShapeType) {
+        Style._apply(to: &type)
+    }
+}
+
+// MARK: - _OpacitiesShapeStyle
+
+@_spi(Private)
+@available(OpenSwiftUI_v3_0, *)
+@frozen
+public struct _OpacitiesShapeStyle<Style>: ShapeStyle, PrimitiveShapeStyle where Style: ShapeStyle {
+    public var style: Style
+
+    public var opacities: [Double]
+
+    @inlinable
+    public init(style: Style, opacities: [Double]) {
+        self.style = style
+        self.opacities = opacities
+    }
+
+    public func _apply(to shape: inout _ShapeStyle_Shape) {
+        switch shape.operation {
+        case .prepareText:
+            shape.result = .preparedText(.foregroundKeyColor)
+        case let .resolveStyle(name, levels):
+            shape.operation = .resolveStyle(name: name, levels: 0..<1)
+            style._apply(to: &shape)
+            let style = shape.stylePack[name, 0]
+            for level in levels {
+                let index = min(level, opacities.count - 1)
+                let opacity = index >= 0 ? opacities[index] : 1.0
+                shape.stylePack[name, level] = style.applyingOpacity(Float(opacity))
+            }
+        case let .fallbackColor(level):
+            shape.operation = .fallbackColor(level: 0)
+            style._apply(to: &shape)
+            if case let .color(color) = shape.result {
+                let index = min(level, opacities.count - 1)
+                let opacity = index >= 0 ? opacities[index] : 1.0
+                shape.result = .color(color.opacity(opacity))
+            }
+        case .copyStyle:
+            style.mapCopiedStyle(in: &shape) { style in
+                _OpacitiesShapeStyle<AnyShapeStyle>(style: style, opacities: opacities)
+            }
+        case .modifyBackground:
+            style._apply(to: &shape)
+        case .multiLevel:
+            shape.result = .bool(true)
+        case .primaryStyle:
+            break
+        }
+    }
+
+    public static func _apply(to type: inout _ShapeStyle_ShapeType) {
+        Style._apply(to: &type)
+    }
+}
 
 // MARK: - OpacityTransition
 
 /// A transition from transparent to opaque on insertion, and from opaque to
 /// transparent on removal.
 @available(OpenSwiftUI_v5_0, *)
+@MainActor
+@preconcurrency
 public struct OpacityTransition: Transition {
-    public init() {}
+    public init() {
+        _openSwiftUIEmptyStub()
+    }
 
     public func body(
         content: OpacityTransition.Content,
@@ -276,7 +405,7 @@ struct OpacityResponderFilter: StatefulRule {
 
 // MARK: - OpacityAccessibilityProvider
 
-protocol OpacityAccessibilityProvider {
+package protocol OpacityAccessibilityProvider {
     static func makeOpacity(
         effect: @autoclosure () -> Attribute<_OpacityEffect>,
         inputs: _ViewInputs,
@@ -300,17 +429,17 @@ struct EmptyOpacityAccessibilityProvider: OpacityAccessibilityProvider {
 
 extension _GraphInputs {
     private struct OpacityAccessibilityProviderKey: GraphInput {
-        static let defaultValue: OpacityAccessibilityProvider.Type = EmptyOpacityAccessibilityProvider.self
+        static let defaultValue: (any OpacityAccessibilityProvider.Type) = EmptyOpacityAccessibilityProvider.self
     }
 
-    var opacityAccessibilityProvider: OpacityAccessibilityProvider.Type {
+    package var opacityAccessibilityProvider: (any OpacityAccessibilityProvider.Type) {
         get { self[OpacityAccessibilityProviderKey.self] }
         set { self[OpacityAccessibilityProviderKey.self] = newValue }
     }
 }
 
 extension _ViewInputs {
-    var opacityAccessibilityProvider: OpacityAccessibilityProvider.Type {
+    package var opacityAccessibilityProvider: (any OpacityAccessibilityProvider.Type) {
         get { base.opacityAccessibilityProvider }
         set { base.opacityAccessibilityProvider = newValue }
     }

Tests/OpenSwiftUICoreTests/Render/RendererEffect/OpacityEffectTests.swift

@@ -0,0 +1,152 @@
+//
+//  OpacityEffectTests.swift
+//  OpenSwiftUICoreTests
+
+@_spi(Private) @testable import OpenSwiftUICore
+import Testing
+import OpenSwiftUITestsSupport
+
+@Suite(.tags(.aigc))
+struct OpacityEffectTests {
+    @Test
+    func opacityScalesOnlyRequestedStylesAndTheirEffects() {
+        var shape = _ShapeStyle_Shape(operation: .resolveStyle(name: .foreground, levels: 1..<3))
+        _OpacityShapeStyle(style: TestStyle(), opacity: 0.5)._apply(to: &shape)
+
+        #expect(shape.stylePack[.foreground, 0].opacity == 0.5)
+        #expect(shape.stylePack[.foreground, 1].opacity == 0.25)
+        #expect(shape.stylePack[.foreground, 2].opacity == 0.25)
+        #expect(shape.stylePack[.foreground, 3].opacity == 0.5)
+        #expect(shape.stylePack[.background, 0].opacity == 0.5)
+        #expect(shape.stylePack[.foreground, 1].effects[0].opacity == 0.125)
+        #expect(shape.stylePack[.foreground, 0].effects[0].opacity == 0.25)
+    }
+
+    @Test(arguments: [Float(0), 0.5, -1, 2])
+    func textRequiresKeyColorForNonidentityOpacity(opacity: Float) {
+        var shape = _ShapeStyle_Shape(operation: .prepareText(level: 0))
+        _OpacityShapeStyle(style: TestStyle(), opacity: opacity)._apply(to: &shape)
+
+        guard case .preparedText(.foregroundKeyColor) = shape.result else {
+            Issue.record("Expected foreground key color")
+            return
+        }
+    }
+
+    @Test
+    func identityOpacityPreservesTextPreparation() {
+        var shape = _ShapeStyle_Shape(operation: .prepareText(level: 0))
+        _OpacityShapeStyle(style: TestStyle(), opacity: 1)._apply(to: &shape)
+
+        guard case .preparedText(.foregroundColor(.red)) = shape.result else {
+            Issue.record("Expected the base style's text color")
+            return
+        }
+    }
+
+    @Test(arguments: [
+        ([Double](), [Float(0.5), 0.5, 0.5, 0.5]),
+        ([Double(0.25)], [Float(0.125), 0.125, 0.125, 0.125]),
+        ([Double(0.25), 0.5], [Float(0.125), 0.25, 0.25, 0.25]),
+        ([Double(-1), 2], [Float(-0.5), 1, 1, 1]),
+    ])
+    func opacitiesUseLevelZeroAndRepeatTheLastValue(opacities: [Double], expected: [Float]) {
+        var shape = _ShapeStyle_Shape(operation: .resolveStyle(name: .foreground, levels: 0..<4))
+        _OpacitiesShapeStyle(style: TestStyle(), opacities: opacities)._apply(to: &shape)
+
+        #expect((0..<4).map { shape.stylePack[.foreground, $0].opacity } == expected)
+        #expect((0..<4).map { shape.stylePack[.foreground, $0].effects[0].opacity } == expected.map { $0 / 2 })
+        guard case .resolveStyle(name: .foreground, levels: 0..<1) = shape.operation else {
+            Issue.record("Expected the base style to resolve level zero")
+            return
+        }
+    }
+
+    @Test
+    func opacitiesPreserveUnrequestedLevels() {
+        var shape = _ShapeStyle_Shape(operation: .resolveStyle(name: .foreground, levels: 2..<4))
+        _OpacitiesShapeStyle(style: TestStyle(), opacities: [0.25, 0.5])._apply(to: &shape)
+
+        #expect(shape.stylePack[.foreground, 0].opacity == 0.5)
+        #expect(shape.stylePack[.foreground, 1].opacity == 0.5)
+        #expect(shape.stylePack[.foreground, 2].opacity == 0.25)
+        #expect(shape.stylePack[.foreground, 3].opacity == 0.25)
+        #expect(shape.stylePack[.background, 0].opacity == 0.5)
+    }
+
+    @Test(arguments: [
+        ([Double](), -1, 1.0),
+        ([Double(0.25), 0.5], -1, 1.0),
+        ([Double(0.25), 0.5], 0, 0.25),
+        ([Double(0.25), 0.5], 1, 0.5),
+        ([Double(0.25), 0.5], 5, 0.5),
+    ])
+    func fallbackColorUsesLevelZero(opacities: [Double], level: Int, expected: Double) {
+        var shape = _ShapeStyle_Shape(operation: .fallbackColor(level: level))
+        _OpacitiesShapeStyle(style: TestStyle(), opacities: opacities)._apply(to: &shape)
+
+        guard case let .color(color) = shape.result else {
+            Issue.record("Expected a fallback color")
+            return
+        }
+        #expect(color == Color.red.opacity(expected))
+        guard case .fallbackColor(level: 0) = shape.operation else {
+            Issue.record("Expected fallback color resolution at level zero")
+            return
+        }
+    }
+
+    @Test
+    func copiedStyleRetainsOpacity() {
+        var shape = _ShapeStyle_Shape(operation: .copyStyle(name: .foreground))
+        _OpacityShapeStyle(style: TestStyle(), opacity: 0.5)._apply(to: &shape)
+        guard case let .style(copied) = shape.result else {
+            Issue.record("Expected a copied style")
+            return
+        }
+        shape.operation = .fallbackColor(level: 0)
+        copied._apply(to: &shape)
+        guard case let .color(color) = shape.result else {
+            Issue.record("Expected the copied style's fallback color")
+            return
+        }
+        #expect(color == Color.red.opacity(0.5))
+    }
+
+    @Test
+    func opacitiesDeclareMultipleLevels() {
+        var shape = _ShapeStyle_Shape(operation: .multiLevel)
+        _OpacitiesShapeStyle(style: TestStyle(), opacities: [])._apply(to: &shape)
+        guard case .bool(true) = shape.result else {
+            Issue.record("Expected a multilevel style even with no opacity values")
+            return
+        }
+    }
+
+    private struct TestStyle: ShapeStyle {
+        func _apply(to shape: inout _ShapeStyle_Shape) {
+            switch shape.operation {
+            case .prepareText:
+                shape.result = .preparedText(.foregroundColor(.red))
+            case .resolveStyle:
+                var style = _ShapeStyle_Pack.Style(.color(.white))
+                style.opacity = 0.5
+                style.effects = [.init(kind: .none, opacity: 0.25, _blend: nil)]
+                var pack = _ShapeStyle_Pack.style(style, name: .foreground)
+                for level in 1..<4 {
+                    pack[.foreground, level] = style
+                }
+                pack[.background, 0] = style
+                shape.result = .pack(pack)
+            case let .fallbackColor(level):
+                shape.result = .color(level == 0 ? .red : .blue)
+            case .copyStyle:
+                shape.result = .style(AnyShapeStyle(self))
+            case .multiLevel:
+                shape.result = .bool(false)
+            case .modifyBackground, .primaryStyle:
+                break
+            }
+        }
+    }
+}