nifty_check/checker/

ui.rs

//! Window and view bodies: elements, conditional and repeated UI, and what each dynamic part
//! of the UI reads.

use std::rc::Rc;

use nifty_runtime::{
    Axis, ButtonStyle, Icon, ImageSize, LabelStyle, Size, StackStyle, ToggleStyle,
};
use nifty_syntax::ast::{self, Arg, ElseBranch, ExprKind as Ast, IfStmt, StmtKind, StringPart};
use nifty_syntax::{Diagnostic, Span};

use super::args::Args;
use super::consts::{
    ALIGNMENTS, BACKDROPS, BUTTON_STYLES, ICONS, JUSTIFICATIONS, SURFACES, TEXT_ALIGNMENTS,
    TEXT_COLORS, TEXT_STYLES,
};
use super::env::Context;
use super::{Checker, Global};
use crate::elements::{self, BoundType, Element, ElementKind, MENU, OPEN, WINDOW};
use crate::hir::{
    Binding, Block, Dynamic, NavItem, Node, Nodes, PlaceRoot, StateSet, Type, WindowDef,
};

const DEFAULT_WINDOW_SIZE: Size = Size::new(480.0, 320.0);

/// Whether `path` names a file wherever the app runs: from the root on macOS or Windows,
/// or the home folder. An empty path names no file, which shows nothing.
fn is_absolute(path: &str) -> bool {
    let mut chars = path.chars();
    let drive_letter = matches!(
        (chars.next(), chars.next(), chars.next()),
        (Some(letter), Some(':'), Some('/' | '\\')) if letter.is_ascii_alphabetic()
    );
    let home = path == "~" || path.starts_with("~/") || path.starts_with("~\\");
    path.is_empty() || drive_letter || home || path.starts_with(['/', '\\'])
}
/// The most lines a text field can be tall, which is more than fit a screen.
const MAX_LINES: u32 = 100;
/// The range a slider covers when its code doesn't say: a percentage.
const DEFAULT_SLIDER_RANGE: (i64, i64) = (0, 100);

/// A call to a built-in element, as written.
pub(super) struct ElementCall<'a> {
    pub element: &'static Element,
    pub args: &'a [Arg],
    pub block: Option<&'a ast::Block>,
    pub span: Span,
}

/// The built-in element `stmt` calls, if it is a call to one by name.
pub(super) fn element_call(stmt: &ast::Stmt) -> Option<ElementCall<'_>> {
    let StmtKind::Expr(ast::Expr {
        kind:
            Ast::Call {
                callee,
                args,
                trailing_block,
            },
        span,
    }) = &stmt.kind
    else {
        return None;
    };
    let Ast::Name(name) = &callee.kind else {
        return None;
    };
    Some(ElementCall {
        element: elements::element(name)?,
        args,
        block: trailing_block.as_ref(),
        span: *span,
    })
}

/// The calls among `stmts` to elements that cover their whole stack, of `kind`.
fn covering(stmts: &[ast::Stmt], kind: ElementKind) -> impl Iterator<Item = ElementCall<'_>> {
    stmts
        .iter()
        .filter_map(element_call)
        .filter(move |call| call.element.kind == kind)
}

/// The elements that cover their whole stack, rather than taking a place in it.
const COVERING: [ElementKind; 2] = [ElementKind::ContextMenu, ElementKind::DropTarget];

impl Checker {
    /// A window's definition; one without a `named` window must start open, since no code
    /// can open it.
    pub(super) fn window(&mut self, call: &ElementCall, named: bool) -> Option<WindowDef> {
        let window = call.element;
        let (trailing_block, span) = (call.block, &call.span);
        let mut args = Args::built_in(self, window.name, window.params, call.args);
        let title = if let Some(title) = args.positional() {
            self.const_string(title)
        } else {
            self.error(
                "`window` needs a title, such as `window(\"My App\")`",
                *span,
            );
            None
        };
        let width = args
            .named("width")
            .and_then(|width| self.const_points(width));
        let height = args
            .named("height")
            .and_then(|height| self.const_points(height));
        let backdrop = args
            .named("backdrop")
            .and_then(|backdrop| self.const_member(backdrop, BACKDROPS))
            .unwrap_or_default();
        let starts_open = args
            .named(OPEN)
            .and_then(|open| self.const_bool(open))
            .unwrap_or(true);
        if !starts_open && !named {
            self.error(
                format!(
                    "a window that starts closed needs a name to open it by, such as `{WINDOW} settings(…)`"
                ),
                *span,
            );
        }
        args.finish(self);
        let Some(block) = trailing_block else {
            self.error("`window` needs a `{ … }` block with its content", *span);
            return None;
        };

        let nodes = self.ui_nodes(&block.stmts);
        let (style, children) = match nodes.as_slice() {
            [
                Node::Stack {
                    style,
                    children,
                    scrolls: false,
                },
            ] => (*style, Rc::clone(children)),
            _ => (StackStyle::new(Axis::Vertical), nodes.into()),
        };
        Some(WindowDef {
            title: title?,
            starts_open,
            size: Size::new(
                width.unwrap_or(DEFAULT_WINDOW_SIZE.width),
                height.unwrap_or(DEFAULT_WINDOW_SIZE.height),
            ),
            backdrop,
            style,
            children,
            locals: self
                .body
                .locals
                .iter()
                .map(|local| local.ty.clone())
                .collect(),
        })
    }

    pub(super) fn ui_block(&mut self, stmts: &[ast::Stmt]) -> Nodes {
        self.ui_nodes(stmts).into()
    }

    fn ui_nodes(&mut self, stmts: &[ast::Stmt]) -> Vec<Node> {
        self.body.push_scope();
        let nodes = stmts.iter().filter_map(|stmt| self.ui_stmt(stmt)).collect();
        self.body.pop_scope();
        self.one_covering_each(stmts);
        nodes
    }

    fn ui_stmt(&mut self, stmt: &ast::Stmt) -> Option<Node> {
        match &stmt.kind {
            StmtKind::Expr(ast::Expr {
                kind:
                    Ast::Call {
                        callee,
                        args,
                        trailing_block,
                    },
                span,
            }) if matches!(callee.kind, Ast::Name(_)) => {
                let Ast::Name(name) = &callee.kind else {
                    return None;
                };
                self.element(name, args, trailing_block.as_ref(), *span)
            }
            StmtKind::If(if_stmt) => Some(self.ui_if(if_stmt, stmt.span)),
            StmtKind::For {
                index,
                item,
                iterable,
                body,
            } => {
                let (head, deps) = self.dynamic(stmt.span, |checker| {
                    checker.loop_head(iterable, index.is_some())
                });
                self.none_covering(&body.stmts);
                let body = self.in_loop(index.as_ref(), item, &head, |checker| {
                    checker.ui_block(&body.stmts)
                });
                Some(Node::For {
                    head: Rc::new(head),
                    body,
                    deps,
                })
            }
            _ => {
                self.error(
                    "only elements, `if` and `for` can appear here; put logic in a function or a button's action",
                    stmt.span,
                );
                None
            }
        }
    }

    fn ui_if(&mut self, if_stmt: &IfStmt, span: Span) -> Node {
        let mut conditions = Vec::new();
        let mut bodies = Vec::new();
        let mut otherwise = None;
        let mut current = if_stmt;
        loop {
            conditions.push(&current.condition);
            bodies.push(&current.then_block);
            match &current.else_branch {
                None => break,
                Some(ElseBranch::Block(block)) => {
                    otherwise = Some(block);
                    break;
                }
                Some(ElseBranch::If(next)) => current = next,
            }
        }
        let (conditions, deps) = self.dynamic(span, |checker| {
            conditions
                .into_iter()
                .map(|condition| checker.expect(condition, &Type::Bool))
                .collect::<Vec<_>>()
        });
        let branches = conditions
            .into_iter()
            .zip(bodies)
            .map(|(condition, body)| (Rc::new(condition), self.ui_block(&body.stmts)))
            .collect();
        let otherwise =
            otherwise.map_or_else(|| Vec::new().into(), |block| self.ui_block(&block.stmts));
        Node::If {
            branches,
            otherwise,
            deps,
        }
    }

    fn element(
        &mut self,
        name: &str,
        args: &[Arg],
        block: Option<&ast::Block>,
        span: Span,
    ) -> Option<Node> {
        let Some(element) = elements::element(name) else {
            let args = Args::new(self, format!("`{name}`"), args);
            return self.view_call(name, args, block, span);
        };
        self.built_in_element(element, args, block, span)
    }

    fn built_in_element(
        &mut self,
        element: &'static Element,
        args: &[Arg],
        block: Option<&ast::Block>,
        span: Span,
    ) -> Option<Node> {
        let name = element.name;
        let mut args = Args::built_in(self, name, element.params, args);
        let node = match element.kind {
            ElementKind::Column | ElementKind::Row | ElementKind::Scroll => {
                let axis = if element.kind == ElementKind::Row {
                    Axis::Horizontal
                } else {
                    Axis::Vertical
                };
                let scrolls = element.kind == ElementKind::Scroll;
                let style = self.stack_style(axis, scrolls, &mut args);
                let children =
                    block.map_or_else(|| Vec::new().into(), |block| self.ui_block(&block.stmts));
                args.finish(self);
                return Some(Node::Stack {
                    style,
                    children,
                    scrolls,
                });
            }
            ElementKind::Label => {
                let text = self.required_text(name, args.positional(), span)?;
                let style = self.label_style(&mut args);
                Node::Label {
                    text: Rc::new(text),
                    style,
                }
            }
            ElementKind::Button => {
                let node = self.button(name, &mut args, block, span);
                args.finish(self);
                return node;
            }
            ElementKind::TextField => {
                let node = self.text_field(name, &mut args, block, span);
                args.finish(self);
                return node;
            }
            ElementKind::Checkbox => {
                self.toggle(name, "checked", ToggleStyle::Checkbox, &mut args, span)?
            }
            ElementKind::Switch => self.toggle(name, "on", ToggleStyle::Switch, &mut args, span)?,
            ElementKind::Slider => self.slider(name, &mut args, span)?,
            ElementKind::Picker => self.picker(name, &mut args, span)?,
            ElementKind::NavItem => self.nav_item(name, &mut args, span)?,
            ElementKind::Image => self.image(name, &mut args, span)?,
            ElementKind::Progress => Node::Progress {
                value: args.named("value").map(|value| Rc::new(self.number(value))),
            },
            ElementKind::Spacer => Node::Spacer,
            ElementKind::Divider => Node::Divider,
            ElementKind::ContextMenu => {
                args.finish(self);
                return self.context_menu(name, block, span);
            }
            ElementKind::DropTarget => {
                let strings = BoundType::Strings.ty();
                let dropped = self.binding(name, None, args.positional(), &strings, span);
                args.finish(self);
                return Some(Node::DropTarget {
                    dropped: Rc::new(dropped?),
                    action: block.map(|block| self.action(block)),
                });
            }
            ElementKind::Window => {
                self.error("a window can only be declared at the top level", span);
                return None;
            }
            ElementKind::Menu | ElementKind::MenuItem => {
                self.error(
                    format!("`{name}` goes in the app's menu bar: in a top-level `{MENU}(…)`"),
                    span,
                );
                return None;
            }
        };
        args.finish(self);
        self.no_block(name, block);
        Some(node)
    }

    /// A stack's settings; a scroll area always grows, so it isn't asked.
    fn stack_style(&mut self, axis: Axis, scrolls: bool, args: &mut Args) -> StackStyle {
        let defaults = StackStyle::new(axis);
        StackStyle {
            axis,
            spacing: args
                .named("spacing")
                .and_then(|spacing| self.const_points(spacing))
                .unwrap_or(defaults.spacing),
            padding: args
                .named("padding")
                .and_then(|padding| self.const_points(padding))
                .unwrap_or(defaults.padding),
            align: args
                .named("align")
                .and_then(|align| self.const_member(align, ALIGNMENTS))
                .unwrap_or(defaults.align),
            justify: args
                .named("justify")
                .and_then(|justify| self.const_member(justify, JUSTIFICATIONS))
                .unwrap_or(defaults.justify),
            surface: args
                .named("surface")
                .and_then(|surface| self.const_member(surface, SURFACES))
                .unwrap_or(defaults.surface),
            grow: scrolls
                || args
                    .named("grow")
                    .and_then(|grow| self.const_bool(grow))
                    .unwrap_or(defaults.grow),
            width: args
                .named("width")
                .and_then(|width| self.const_points(width))
                .unwrap_or(defaults.width),
            max_width: args
                .named("max_width")
                .and_then(|max_width| self.const_points(max_width))
                .unwrap_or(defaults.max_width),
        }
    }

    fn image(&mut self, name: &str, args: &mut Args, span: Span) -> Option<Node> {
        let path = args.positional();
        if let Some(path) = path
            && let Ast::String(parts) = &path.kind
            && let [StringPart::Text(text)] = &parts[..]
            && !is_absolute(text)
        {
            self.error(
                format!("`{name}` needs a full path, or one starting with `~`; images that come with an app aren't supported yet"),
                path.span,
            );
        }
        let path = self.required_text(name, path, span)?;
        let size = ImageSize {
            width: args
                .named("width")
                .and_then(|width| self.const_points(width))
                .unwrap_or(ImageSize::FIT),
            height: args
                .named("height")
                .and_then(|height| self.const_points(height))
                .unwrap_or(ImageSize::FIT),
        };
        Some(Node::Image {
            path: Rc::new(path),
            size,
        })
    }

    fn text_field(
        &mut self,
        name: &str,
        args: &mut Args,
        block: Option<&ast::Block>,
        span: Span,
    ) -> Option<Node> {
        let value = self.binding(name, None, args.positional(), &Type::String, span);
        let placeholder = args.named("placeholder");
        let placeholder_text = placeholder.and_then(|placeholder| self.const_string(placeholder));
        let lines = args
            .named("lines")
            .and_then(|lines| self.line_count(lines))
            .unwrap_or(1);
        if let Some(placeholder) = placeholder
            && lines > 1
        {
            self.error(
                format!("`{name}` shows a placeholder only on one line, with no `lines:`"),
                placeholder.span,
            );
        }
        if let Some(block) = block
            && lines > 1
        {
            self.error(
                format!("`{name}` takes Return as a new line when it has `lines:`, so it can't take a `{{ … }}` block to run on Return"),
                block.span,
            );
        }
        let action = block.map(|block| self.action(block));
        Some(Node::TextField {
            value: Rc::new(value?),
            placeholder: placeholder_text.unwrap_or_default(),
            lines,
            action,
        })
    }

    /// How many lines a text field is tall: at least one, and no more than fit a screen.
    fn line_count(&mut self, expr: &ast::Expr) -> Option<u32> {
        let count = self.const_number(expr)?;
        let lines = u32::try_from(count)
            .ok()
            .filter(|lines| (1..=MAX_LINES).contains(lines));
        if lines.is_none() {
            self.error(format!("this must be between 1 and {MAX_LINES}"), expr.span);
        }
        lines
    }

    fn button(
        &mut self,
        name: &str,
        args: &mut Args,
        block: Option<&ast::Block>,
        span: Span,
    ) -> Option<Node> {
        let title = self.required_text(name, args.positional(), span)?;
        let style = args
            .named("style")
            .and_then(|style| self.const_member(style, BUTTON_STYLES))
            .unwrap_or(ButtonStyle::Normal);
        let icon = self.icon(args);
        let selected = args.named("selected").map(|selected| {
            if style == ButtonStyle::Primary {
                self.error(
                    "a `.primary` button is the window's default action, so it can't be `selected`; pick another style",
                    selected.span,
                );
            }
            Rc::new(self.condition(selected))
        });
        let Some(block) = block else {
            self.error("`button` needs a `{ … }` block with what it does", span);
            return None;
        };
        let action = self.action(block);
        Some(Node::Button {
            title: Rc::new(title),
            style,
            icon,
            selected,
            action,
        })
    }

    /// A `checkbox` or `switch`, whose binding is labelled `label`.
    fn toggle(
        &mut self,
        name: &str,
        label: &str,
        style: ToggleStyle,
        args: &mut Args,
        span: Span,
    ) -> Option<Node> {
        let checked = self.binding(name, Some(label), args.named(label), &Type::Bool, span);
        let title = args
            .named("title")
            .map(|title| Rc::new(self.text(name, title)));
        Some(Node::Checkbox {
            checked: Rc::new(checked?),
            title,
            style,
        })
    }

    fn slider(&mut self, name: &str, args: &mut Args, span: Span) -> Option<Node> {
        let value = self.binding(name, None, args.positional(), &Type::Int, span);
        let (default_min, default_max) = DEFAULT_SLIDER_RANGE;
        let min = args
            .named("min")
            .map(|min| (min.span, self.const_number(min)));
        let max = args
            .named("max")
            .map(|max| (max.span, self.const_number(max)));
        let (min_span, min) = min.unwrap_or((span, Some(default_min)));
        let (max_span, max) = max.unwrap_or((span, Some(default_max)));
        let (min, max) = (min?, max?);
        if min > max {
            self.error(
                format!("`{name}` needs `min` no higher than `max`, but {min} is above {max}"),
                min_span.to(max_span),
            );
            return None;
        }
        Some(Node::Slider {
            value: Rc::new(value?),
            min,
            max,
        })
    }

    fn picker(&mut self, name: &str, args: &mut Args, span: Span) -> Option<Node> {
        let selection = self.binding(name, None, args.positional(), &Type::String, span);
        let options = args
            .named("options")
            .map(|options| self.shown(options, &Type::List(Rc::new(Type::String))));
        if options.is_none() {
            self.error(
                format!("`{name}` needs `options:`, the strings to pick from, such as `options: [\"Low\", \"High\"]`"),
                span,
            );
        }
        let (selection, options) = (selection?, options?);
        let mut deps = selection.deps.clone();
        deps.extend(&options.deps);
        Some(Node::Picker {
            selection: Rc::new(selection),
            options: Rc::new(options),
            deps,
        })
    }

    fn nav_item(&mut self, name: &str, args: &mut Args, span: Span) -> Option<Node> {
        let title = self.required_text(name, args.positional(), span);
        let value = args.named("value").map(|value| self.text(name, value));
        if value.is_none() {
            self.error(
                format!("`{name}` needs `value:`, what `selection` holds while it's picked"),
                span,
            );
        }
        let selection = self.binding(
            name,
            Some("selection"),
            args.named("selection"),
            &Type::String,
            span,
        );
        let icon = self.icon(args);
        let badge = args.named("badge").map(|badge| self.text(name, badge));
        let (title, value, selection) = (title?, value?, selection?);
        let mut deps = title.deps.clone();
        deps.extend(&value.deps);
        deps.extend(&selection.deps);
        if let Some(badge) = &badge {
            deps.extend(&badge.deps);
        }
        Some(Node::NavItem(NavItem {
            title: Rc::new(title),
            value: Rc::new(value),
            selection: Rc::new(selection),
            icon,
            badge: badge.map(Rc::new),
            deps,
        }))
    }

    fn icon(&mut self, args: &mut Args) -> Icon {
        args.named("icon")
            .and_then(|icon| self.const_member(icon, ICONS))
            .unwrap_or_default()
    }

    fn label_style(&mut self, args: &mut Args) -> LabelStyle {
        let font = args
            .named("style")
            .and_then(|style| self.const_member(style, TEXT_STYLES))
            .unwrap_or_default();
        let defaults = LabelStyle::new(font);
        LabelStyle {
            font,
            color: args
                .named("color")
                .and_then(|color| self.const_member(color, TEXT_COLORS))
                .unwrap_or(defaults.color),
            align: args
                .named("align")
                .and_then(|align| self.const_member(align, TEXT_ALIGNMENTS))
                .unwrap_or(defaults.align),
            selectable: args
                .named("selectable")
                .and_then(|selectable| self.const_bool(selectable))
                .unwrap_or(defaults.selectable),
        }
    }

    fn view_call(
        &mut self,
        name: &str,
        mut args: Args,
        block: Option<&ast::Block>,
        span: Span,
    ) -> Option<Node> {
        let Some(Global::View(view)) = self.global(name) else {
            args.finish(self);
            let message = match self.global(name) {
                Some(Global::Fn(_)) => format!(
                    "`{name}` is a function; call it from a button's action, or show its result with `label`"
                ),
                _ => format!("unknown element or view `{name}`"),
            };
            self.error(message, span);
            return None;
        };
        let params = self.view_params[view.0].clone();
        let (checked, deps) = self.dynamic(span, |checker| {
            let mut checked = Vec::new();
            for (param, ty) in &params {
                let arg = args.param(param);
                checked.push(checker.required_arg(arg, ty, span, || {
                    format!("`{name}` needs an argument for `{param}`")
                }));
            }
            checked
        });
        args.finish(self);
        self.no_block(name, block);
        Some(Node::View {
            view,
            args: checked.into(),
            deps,
        })
    }

    /// Reports each element in `stmts` that covers its stack after the first of its kind:
    /// a stack has one context menu and one drop target.
    fn one_covering_each(&mut self, stmts: &[ast::Stmt]) {
        for kind in COVERING {
            let mut calls = covering(stmts, kind);
            let Some(first) = calls.next() else {
                continue;
            };
            for extra in calls {
                let name = extra.element.name;
                self.diagnostics.push(
                    Diagnostic::new(format!("a stack has one `{name}`"), extra.span)
                        .with_note("its first is this one", first.span),
                );
            }
        }
    }

    /// Reports an element that covers its stack straight in a `for`'s body, which would
    /// cover the stack around the loop once for each item.
    fn none_covering(&mut self, body: &[ast::Stmt]) {
        for kind in COVERING {
            for call in covering(body, kind) {
                self.error(
                    format!(
                        "a `{}` here would cover the stack around the `for` once per item; put it in a `row` or `column` inside the loop",
                        call.element.name
                    ),
                    call.span,
                );
            }
        }
    }

    /// Reports a block given to `name`, which takes none.
    pub(super) fn no_block(&mut self, name: &str, block: Option<&ast::Block>) {
        if let Some(block) = block {
            self.error(
                format!("`{name}` doesn't take a `{{ … }}` block"),
                block.span,
            );
        }
    }

    fn required_text(
        &mut self,
        element: &str,
        expr: Option<&ast::Expr>,
        span: Span,
    ) -> Option<Dynamic> {
        if let Some(expr) = expr {
            return Some(self.text(element, expr));
        }
        self.error(
            format!("`{element}` needs its text, such as `{element}(\"Hello\")`"),
            span,
        );
        None
    }

    /// Text the UI shows; it updates whenever the state it reads changes.
    fn text(&mut self, element: &str, expr: &ast::Expr) -> Dynamic {
        let (expr, deps) =
            self.dynamic(expr.span, |checker| checker.expr(expr, Some(&Type::String)));
        match &expr.ty {
            Type::String | Type::Error => {}
            Type::Int | Type::Float | Type::Bool => self.error(
                format!(
                    "`{element}` shows text; turn this `{}` into text with \"{{…}}\"",
                    self.type_name(&expr.ty)
                ),
                expr.span,
            ),
            other => self.require(&other.clone(), &Type::String, expr.span),
        }
        Dynamic { expr, deps }
    }

    /// An `int` the UI shows; it updates whenever the state it reads changes.
    fn number(&mut self, expr: &ast::Expr) -> Dynamic {
        self.shown(expr, &Type::Int)
    }

    /// A `bool` the UI shows; it updates whenever the state it reads changes.
    fn condition(&mut self, expr: &ast::Expr) -> Dynamic {
        self.shown(expr, &Type::Bool)
    }

    /// A value of type `ty` the UI shows; it updates whenever the state it reads changes.
    fn shown(&mut self, expr: &ast::Expr, ty: &Type) -> Dynamic {
        let (expr, deps) = self.dynamic(expr.span, |checker| checker.expect(expr, ty));
        Dynamic { expr, deps }
    }

    fn binding(
        &mut self,
        element: &str,
        label: Option<&str>,
        expr: Option<&ast::Expr>,
        ty: &Type,
        span: Span,
    ) -> Option<Binding> {
        let (place, deps) = self.dynamic(expr.map_or(span, |expr| expr.span), |checker| {
            let place = checker.bound_place(element, label, expr, ty, span)?;
            if let PlaceRoot::State(state) = place.root {
                checker.effects.reads.insert(state);
            }
            Some(place)
        });
        Some(Binding {
            place: place?,
            deps,
        })
    }

    /// A button's action: statements that may change state.
    pub(super) fn action(&mut self, block: &ast::Block) -> Block {
        let outer = std::mem::replace(&mut self.body.context, Context::Action);
        let action = self.block(block);
        self.body.context = outer;
        action
    }

    /// Checks UI code and returns the state it reads. Building the UI must not change state,
    /// since it runs again whenever that state changes.
    fn dynamic<T>(&mut self, span: Span, check: impl FnOnce(&mut Self) -> T) -> (T, StateSet) {
        let (result, effects) = self.measure(check);
        let (reads, writes) = self.fn_effects.total(&effects);
        if writes {
            self.error(
                "showing the UI can't change state; do that in a button's action",
                span,
            );
        }
        (result, reads)
    }
}