Summary

This PR adds on_click, args, kwargs, and key support to st.link_button while preserving prior default behavior (on_click="ignore"). The implementation updates backend widget wiring, frontend click handling, and protobuf shape, with accompanying Python/frontend/typing tests.

Code Quality

Overall code structure is solid and follows existing patterns used by button/download_button:

• Backend changes in lib/streamlit/elements/widgets/button.py are cohesive and keep behavior centralized in _link_button.
• Frontend wiring in frontend/lib/src/components/core/Block/ElementNodeRenderer.tsx and frontend/lib/src/components/elements/LinkButton/LinkButton.tsx is straightforward and uses the existing WidgetStateManager trigger path correctly.
• Test updates are targeted and readable across backend, frontend, and typing suites.

No blocking code-quality issues were identified.

Test Coverage

Coverage is good for unit-level behavior:

• Backend tests validate ignore/rerun state signaling, key behavior, invalid key rejection, and stable key-based identity (lib/tests/streamlit/elements/link_button_test.py, lib/tests/streamlit/elements/button_test.py).
• Frontend tests verify rerun trigger behavior, fragment propagation, default ignore behavior, and disabled behavior (frontend/lib/src/components/elements/LinkButton/LinkButton.test.tsx).
• Typing tests cover the newly exposed public API surface (lib/tests/streamlit/typing/button_types.py).

Residual gap: there is no e2e test validating real browser behavior for "open new tab + rerun/callback trigger" in one flow.

Backwards Compatibility

Backwards compatibility looks good:

• Default st.link_button behavior remains non-rerunning (on_click="ignore").
• New parameters are optional keyword arguments, so existing call sites continue to work.
• The new protobuf field (ignore_rerun) is additive, which is wire-compatible.

No breaking API changes were found.

Security & Risk

No security issues were identified in this change set:

• No new privileged operations, unsafe parsing, or dynamic code execution paths were introduced.
• Callback execution continues through established widget callback infrastructure.

Main regression risk is behavioral (UI flow), not security: browser-level interaction timing between navigation and rerun is not covered by e2e.

Accessibility

Frontend changes preserve good accessibility semantics:

• LinkButton remains an anchor-based control (<a href> behavior via BaseLinkButton), which is appropriate for navigation.
• No new non-semantic clickable containers were introduced.
• No ARIA regressions were observed in the modified code paths.

Recommendations

1. Add one focused e2e test for st.link_button(on_click="rerun") (and optionally callable mode) to validate end-to-end browser behavior, including fragment context.

Verdict

APPROVED: The implementation is consistent, backward-compatible, and sufficiently covered by unit/typing tests, with only a non-blocking e2e coverage gap.

This is an automated AI review by gpt-5.3-codex-high. Please verify the feedback and use your judgment.

Summary

This PR adds on_click, args, kwargs, and key support to st.link_button, following the same pattern established by st.download_button. The default on_click="ignore" preserves the existing no-rerun behavior. When set to "rerun" or a callable, the link still opens in a new tab but the app also triggers a rerun (optionally invoking the callback). The implementation spans the full stack:

• Proto: Adds bool ignore_rerun = 13 to LinkButton.proto.
• Backend: Extends link_button() and _link_button() with new parameters; conditionally registers the widget and validates keys.
• Frontend: LinkButton component gains widgetMgr and fragmentId props; handleClick conditionally calls setTriggerValue.
• Tests: Backend unit tests, frontend unit tests, and typing tests are added/updated.

Code Quality

The code is clean, well-structured, and follows existing patterns closely. Specific observations:

• The backend implementation in _link_button (lib/streamlit/elements/widgets/button.py:1283-1375) closely mirrors the _download_button pattern for on_click handling, which promotes consistency.
• The should_register_element_id logic (line 1314-1316) correctly handles the three distinct cases (rerun mode, key provided, shortcut provided) for determining when an element ID is needed.
• The check_widget_policies guard (line 1317) correctly only fires when the element acts as a widget (rerun mode or key provided), not for the shortcut-only path.
• The key_as_main_identity expression (not ignore_rerun or key is not None, line 1330) ensures stable identity when the link button is used as a widget, while preserving content-based identity for the shortcut-only case.
• The frontend handleClick callback (line 61-73 of LinkButton.tsx) correctly guards the trigger with both !element.ignoreRerun and element.id, and the dependency array [element, fragmentId, widgetMgr] is complete and correct.
• The change from {...elementProps} to explicit widgetMgr and fragmentId props in ElementNodeRenderer.tsx (line 915-919) is an improvement — the old code was spreading unused props (disableFullscreenMode, widthConfig, heightConfig) that LinkButton never consumed.
• Minor style improvement: element.shortcut || undefined (line 42) is equivalent to the previous ternary and is more concise.
• The icon_position parameter is now included in compute_and_register_element_id (line 1338), which was missing before. This is a minor improvement for identity uniqueness in the shortcut-only case.

Test Coverage

Test coverage is solid across all layers:

• Python unit tests (link_button_test.py): Tests the default ignore_rerun flag, key-setting in ignore mode, invalid key rejection (empty and reserved prefix), rerun/callback mode enabling. Good use of @parameterized.expand and anti-regression assertions.
• Python unit tests (button_test.py): Tests stable key-based identity for both rerun/callback and ignore modes, including varying callback args.
• Frontend unit tests (LinkButton.test.tsx): Tests no-rerun by default, rerun with/without fragmentId (it.each), and disabled-prevents-rerun. Uses WidgetStateManager spy pattern properly.
• Typing tests (button_types.py): Comprehensive assert_type coverage for the new key, on_click, args, kwargs parameters.
• E2E tests: Not added. The PR justification — "behavior is covered by backend + frontend unit tests for this API-focused change" — is reasonable. The underlying setTriggerValue mechanism is already E2E-tested via other widgets. The existing E2E tests in st_link_button_test.py still pass since the default behavior is unchanged.

One minor gap: there is no test verifying that the shortcut path still works correctly with on_click="rerun" (i.e., that pressing a shortcut on a link button with on_click="rerun" triggers both the link navigation and the rerun). This is covered implicitly by the existing shortcut E2E test and the unit test for setTriggerValue, but an explicit test could add confidence.

Backwards Compatibility

This change is fully backwards compatible:

• All new parameters (key, on_click, args, kwargs) are keyword-only with sensible defaults (None, "ignore", None, None).
• The default on_click="ignore" preserves the existing no-rerun, no-widget-registration behavior.
• The _link_button internal method signature changes help from a required positional parameter to an optional keyword parameter, but this method is private and the only caller is the public link_button method (confirmed via search).
• The protobuf addition (ignore_rerun = 13) is purely additive. The proto3 default of false combined with the frontend guard !element.ignoreRerun && element.id ensures safe behavior: old backends that don't set this field will have element.id as empty string for non-shortcut link buttons, so the rerun path won't fire.

Security & Risk

No security concerns identified:

• The on_click callback mechanism uses the same register_widget / check_widget_policies infrastructure as existing widgets.
• writes_allowed=False correctly prevents session state writes.
• No new external inputs or URL handling is introduced.
• The link still opens via the native <a href> mechanism in a new tab; the rerun is a separate side effect.

Accessibility

No accessibility regressions:

• The component continues to render a semantic <a> element with aria-disabled, target="_blank", and rel="noreferrer".
• No new interactive elements are introduced.
• The keyboard shortcut integration is unchanged.
• The click handler correctly prevents link navigation when disabled, preserving the existing behavior for assistive technology users.

Recommendations

1. Consider adding an E2E test scenario for on_click="rerun" to the existing st_link_button_test.py file. While unit tests cover the mechanism well, a single E2E scenario would verify the full-stack callback flow (click link button -> app reruns -> callback output visible). This could be a follow-up.
2. Docstring example: The docstring for link_button only shows the basic example (st.link_button("Go to gallery", ...)). Consider adding a brief example showing on_click usage in a follow-up, similar to how st.download_button documents its on_click parameter in examples.

Verdict

APPROVED: Well-implemented feature that follows established patterns, is fully backwards compatible, and has thorough test coverage across all layers.

This is an automated AI review by opus-4.6-thinking.