Debug runaway window update recursion, impl menu ForEach support

ForEach support in MenuItemsBuilder currently requires an explicit type
annotation. The only way I see to get around that is to make menus just
use ViewBuilder, but I really don't want to do that because then we need
to support state in menus, and things start getting a bit dodgy and
approximate (e.g. users of scui would have no way of knowing which view
types work in menus and which don't).

Author: stackotter

Sources/GtkBackend/GtkBackend.swift

@@ -807,7 +807,7 @@ public final class GtkBackend: AppBackend {
             configure: { chooser in
                 chooser.selectMultiple = openDialogOptions.allowMultipleSelections
             },
-            window: window,
+            window: window ?? windows[0],
             resultHandler: handleResult
         )
     }
@@ -826,7 +826,7 @@ public final class GtkBackend: AppBackend {
                     chooser.setCurrentName(defaultFileName)
                 }
             },
-            window: window
+            window: window ?? windows[0]
         ) { result in
             switch result {
                 case .success(let urls):

Sources/SwiftCrossUI/Builders/MenuItemsBuilder.swift

@@ -17,32 +17,45 @@ public struct MenuItemsBuilder {
         first.items
     }
 
+    public static func buildPartialBlock<Items: Collection>(
+        first: ForEach<Items, [MenuItem]>
+    ) -> [MenuItem] {
+        first.elements.map(first.child).flatMap { $0 }
+    }
+
     public static func buildPartialBlock(
         accumulated: [MenuItem],
         next: Button
     ) -> [MenuItem] {
-        accumulated + [.button(next)]
+        accumulated + buildPartialBlock(first: next)
     }
 
     public static func buildPartialBlock(
         accumulated: [MenuItem],
         next: Text
     ) -> [MenuItem] {
-        accumulated + [.text(next)]
+        accumulated + buildPartialBlock(first: next)
     }
 
     public static func buildPartialBlock(
         accumulated: [MenuItem],
         next: Menu
     ) -> [MenuItem] {
-        accumulated + [.submenu(next)]
+        accumulated + buildPartialBlock(first: next)
     }
 
     public static func buildPartialBlock(
         accumulated: [MenuItem],
         next: Block
     ) -> [MenuItem] {
-        accumulated + next.items
+        accumulated + buildPartialBlock(first: next)
+    }
+
+    public static func buildPartialBlock<Items: Collection>(
+        accumulated: [MenuItem],
+        next: ForEach<Items, [MenuItem]>
+    ) -> [MenuItem] {
+        accumulated + buildPartialBlock(first: next)
     }
 
     public static func buildOptional(_ component: [MenuItem]?) -> Block {

Sources/SwiftCrossUI/LayoutSystem.swift

@@ -6,9 +6,14 @@ public enum LayoutSystem {
                 _ environment: EnvironmentValues,
                 _ dryRun: Bool
             ) -> ViewSize
+        var tag: String?
 
-        public init(update: @escaping (SIMD2<Int>, EnvironmentValues, Bool) -> ViewSize) {
+        public init(
+            update: @escaping (SIMD2<Int>, EnvironmentValues, Bool) -> ViewSize,
+            tag: String? = nil
+        ) {
             self.update = update
+            self.tag = tag
         }
 
         public func update(
@@ -107,7 +112,12 @@ public enum LayoutSystem {
                     dryRun: dryRun
                 )
                 if size.size != .zero || size.participateInStackLayoutsWhenEmpty {
-                    print("warning: Hidden view became visible on second update. Layout may break.")
+                    print(
+                        """
+                        warning: Hidden view became visible on second update. \
+                        Layout may break. View: \(child.tag ?? "<unknown type>")
+                        """
+                    )
                 }
                 renderedChildren[index] = .hidden
                 continue

Sources/SwiftCrossUI/Scenes/WindowGroupNode.swift

@@ -48,6 +48,7 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
             guard let self else {
                 return
             }
+            print("Resized. newSize: \(newSize)")
             _ = self.update(
                 scene,
                 proposedWindowSize: newSize,
@@ -80,7 +81,8 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
         _ newScene: WindowGroup<Content>?,
         proposedWindowSize: SIMD2<Int>,
         backend: Backend,
-        environment: EnvironmentValues
+        environment: EnvironmentValues,
+        windowSizeIsFinal: Bool = false
     ) -> ViewSize {
         guard let window = window as? Backend.Window else {
             fatalError("Scene updated with a backend incompatible with the window it was given")
@@ -121,33 +123,42 @@ public final class WindowGroupNode<Content: View>: SceneGraphNode {
             with: newScene?.body,
             proposedSize: proposedWindowSize,
             environment: environment,
-            dryRun: true
-        )
-
-        let newWindowSize = computeNewWindowSize(
-            currentProposedSize: proposedWindowSize,
-            backend: backend,
-            contentSize: contentSize,
-            environment: environment
+            dryRun: windowSizeIsFinal
         )
 
-        // Restart the window update if the content has caused the window to
-        // change size.
-        if let newWindowSize {
-            return update(
-                scene,
-                proposedWindowSize: newWindowSize,
+        if !windowSizeIsFinal {
+            let newWindowSize = computeNewWindowSize(
+                currentProposedSize: proposedWindowSize,
                 backend: backend,
+                contentSize: contentSize,
                 environment: environment
             )
+
+            // Restart the window update if the content has caused the window to
+            // change size. To avoid infinite recursion, we take the view's word
+            // and assume that it will take on the minimum/maximum size it claimed.
+            if let newWindowSize {
+                return update(
+                    scene,
+                    proposedWindowSize: newWindowSize,
+                    backend: backend,
+                    environment: environment,
+                    windowSizeIsFinal: true
+                )
+            }
         }
 
-        let finalContentSize = viewGraph.update(
-            with: newScene?.body,
-            proposedSize: proposedWindowSize,
-            environment: environment,
-            dryRun: false
-        )
+        let finalContentSize: ViewSize
+        if windowSizeIsFinal {
+            finalContentSize = contentSize
+        } else {
+            finalContentSize = viewGraph.update(
+                with: newScene?.body,
+                proposedSize: proposedWindowSize,
+                environment: environment,
+                dryRun: false
+            )
+        }
 
         // The Gtk 3 backend has some broken sizing code that can't really be
         // fixed due to the design of Gtk 3. Our layout system underestimates

Sources/SwiftCrossUI/Views/ForEach.swift

@@ -1,16 +1,29 @@
 /// A view that displays a variable amount of children.
-public struct ForEach<
-    Items: Collection,
-    Child: View
->: TypeSafeView, View where Items.Index == Int {
-    typealias Children = ForEachViewChildren<Items, Child>
-
-    public var body = EmptyView()
-
+public struct ForEach<Items: Collection, Child> where Items.Index == Int {
     /// A variable-length collection of elements to display.
     var elements: Items
     /// A method to display the elements as views.
     var child: (Items.Element) -> Child
+}
+
+extension ForEach where Child == [MenuItem] {
+    /// Creates a view that creates child views on demand based on a collection of data.
+    @_disfavoredOverload
+    public init(
+        _ elements: Items,
+        @MenuItemsBuilder _ child: @escaping (Items.Element) -> [MenuItem]
+    ) {
+        self.elements = elements
+        self.child = child
+    }
+}
+
+extension ForEach: TypeSafeView, View where Child: View {
+    typealias Children = ForEachViewChildren<Items, Child>
+
+    public var body: EmptyView {
+        return EmptyView()
+    }
 
     /// Creates a view that creates child views on demand based on a collection of data.
     public init(