What causes "Expected to render a table row" in zed-industries/zed?

Derive row_count and the render data from the same immutable snapshot so they cannot disagree within a frame.

Expected to render a table row

Error message

Expected to render a table row

What it means

The tabular data preview renders CSV/database tables in GPUI. In the table render mechanism each visible row goes through render_single_table_row, which returns Option; the render callback unwraps it and panics when None (crates/tabular_data_preview/src/renderer/render_table.rs:75). The panic means the component advertised row_count rows but could not produce one for an index GPUI asked to draw.

Source

Thrown at crates/tabular_data_preview/src/renderer/render_table.rs:75

            .pin_cols(1)
            .map(|table| {
                let row_identifier_text_color = cx.theme().colors().editor_line_number;
                match self.settings.rendering_with {
                    RowRenderMechanism::VariableList => {
                        table.variable_row_height_list(row_count, self.list_state.clone(), {
                            cx.processor(move |this, display_row: usize, _window, cx| {
                                this.performance_metrics.rendered_indices.push(display_row);

                                let display_row = DisplayRow(display_row);
                                Self::render_single_table_row(
                                    this,
                                    cols,
                                    display_row,
                                    row_identifier_text_color,
                                    this.row_height,
                                    cx,
                                )
                                .unwrap_or_else(|| panic!("Expected to render a table row"))
                            })
                        })
                    }
                    RowRenderMechanism::UniformList => {
                        table.uniform_list("tabular-data-table", row_count, {
                            cx.processor(move |this, range: Range<usize>, _window, cx| {
                                // Record all display indices in the range for performance metrics
                                this.performance_metrics
                                    .rendered_indices
                                    .extend(range.clone());

                                let row_height = this.row_height;
                                range
                                    .filter_map(|display_index| {
                                        Self::render_single_table_row(
                                            this,
                                            cols,
                                            DisplayRow(display_index),

View on GitHub (pinned to f4178619ac)

Solutions

Derive row_count and the render data from the same immutable snapshot so they cannot disagree within a frame.
If rows can be transiently unavailable, change render_single_table_row to return a placeholder element instead of None and drop the unwrap_or_else panic.
Reproduce with the triggering file and log the requested display row versus available rows to find which source (CSV reader, DB page) came up short.
Check visible-range arithmetic for an end one past the last row.

Example fix

// before
.unwrap_or_else(|| panic!("Expected to render a table row"))

// after
.unwrap_or_else(|| empty_row_placeholder(row_height, cx))

Defensive patterns

Strategy: validation

Prevention

Derive row_count and render data from the same snapshot each frame.
Treat render callbacks as total over the advertised range.
Test previews with empty files, single-row files, and row counts that change while streaming.
Prefer returning a placeholder element over None in row renderers.

When it happens

Trigger: The table element requests a display row the data source cannot resolve: the row_count passed to the table is larger than the rows the current snapshot can render (streaming/async data not yet loaded or truncated), or the display-row to data-row mapping returns None for a visible index.

Common situations: Previewing a file whose row count is initially estimated or changes mid-render; a background parse finishing while the frame renders; off-by-one in visible-range math for large files.

Related errors

AI-assisted analysis of zed-industries/zed@f4178619ac (2026-08-20). Data as JSON: /api/errors/2f151e2bcfdd5c93. Report an issue: GitHub.