Update design for PR rust-lang#16093: feat(format_push_string): give a (possibly incomplete) suggestion

Author: gauravagerwala

.exp/design-workflow-1-cargo-clippy.md

@@ -61,7 +61,8 @@ sequenceDiagram
     LS->>CL: Register declared_lints::LINTS
     CL-->>LS: Lint metadata registered
     LS->>CL: clippy_lints::register_lint_passes(store, conf)
-    CL-->>LS: LintPass instances registered (filtered by conf)
+    Note right of CL: internally: initialize shared resources (e.g., FormatArgsStorage::default())
+    CL-->>LS: LintPass instances registered (filtered by conf, some stateful with cloned resources)
     Note over RI: Compilation pipeline executes:<br/>- Parse to AST<br/>- Expand/lower to HIR<br/>- MIR construction<br/>- At each phase, applicable lints run via visitors/checkers
     alt --fix mode
         Note over CL,RI: Lints emit rustfix suggestions

.exp/design-workflow-2-clippy-driver.md

@@ -49,7 +49,7 @@ sequenceDiagram
         D->>D: Add --cfg clippy, CLIPPY_ARGS
         D->>RD: run_compiler(args, ClippyCallbacks)
         RD->>C: config() - load conf, set opts (mir_opt_level=0)
-        C->>LS: register_lint_passes() - add early/late lints
+        C->>LS: register_lint_passes() - init shared resources (e.g., FormatArgsStorage), add early/late lints (some with state)
         RD->>C: psess_created() - track deps (Cargo.toml, etc.)
         RD->>CP: Run phases (parse, expand, typeck, MIR, ...)
         loop During phases

.exp/design-workflow-5-lint-development.md

@@ -57,7 +57,8 @@ sequenceDiagram
     User->>CargoClippy: run cargo clippy on project
     CargoClippy->>Driver: invoke driver as rustc wrapper
     Driver->>LintsCrate: load and call register_lint_passes on store
-    LintsCrate->>Store: extend early and late lint passes with lint impls
+    LintsCrate->>LintsCrate: initialize shared resources (e.g., FormatArgsStorage::default())
+    LintsCrate->>Store: extend early and late lint passes with lint impls (passing cloned resources to stateful lints)
     Driver->>Store: create LintListBuilder, insert declared_lints LINTS, register lints and groups
     Driver->>Compiler: run compilation with registered lints
     Store->>Compiler: execute lint passes during compilation phases
@@ -83,14 +84,16 @@ The \`update_lints\` tool parses all \`declare_clippy_lint!\` macros across \`cl
 
 This ensures new lints are automatically included when compiling \`clippy_lints\`.
 
-### Lint Implementation Details
+### Lint Implementation Details (updated)
 
 - **Declaration**: \`declare_clippy_lint!\` expands to \`declare_tool_lint!\` (from rustc) plus \`LintInfo\` static with category, explanation, etc.
-- **Passes**: Early passes (AST/HIR pre-analysis) vs. late (after typeck, access to MIR/ty).
+- **Passes**: Early passes (AST/HIR pre-analysis) vs. late (after typeck, access to MIR/ty). Updated.
 - **Hooks**: Lints impl methods like \`check_expr\`, \`check_item\` using visitor patterns or queries via \`cx\`.
 - **Groups and Levels**: Lints assigned to categories (correctness, style, etc.) auto-grouped by \`LintListBuilder\`; levels (Allow, Warn, Deny).
 - **Fixes**: Use \`rustfix::diagnostics::Diagnostic::fix` for auto-fixes via \`--fix\`.
 
+- **Stateful Passes**: Some lints require state for efficient analysis, such as \`FormatArgsStorage\` from \`clippy_utils::macros\` for parsing \`format!\` and other formatting macros. This storage is created once in \`clippy_lints/src/lib.rs::register_lint_passes\` and cloned into the constructors of relevant lint passes (e.g., lints in \`format_args\` group). This pattern allows sharing parsed data across invocations. The \`format_push_string\` lint, enhanced in [PR #16093](https://github.com/rust-lang/rust-clippy/pull/16093), uses this to detect \`format!\` calls even in nested contexts and generate code suggestions replacing them with \`write!\`.
+
 ### Edge Cases and Extensibility
 
 - **Submodule Placement**: Specify via \`--type <submod>\` (e.g., cargo, methods); affects file path and lib.rs mods.

pr-analysis-16093.md

@@ -0,0 +1,70 @@
+# PR #16093: Workflow Design Impact Analysis
+
+## Affected Workflows
+- **cargo-clippy** (Workflow 1): The PR changes code in `clippy_lints/src/` (lint implementation and registration), which is executed during Cargo project analysis via the clippy-driver wrapper. This impacts the diagnostics produced in the workflow's output.
+
+- **clippy-driver** (Workflow 2): Direct changes to lint passes registered by the driver, affecting individual file or non-Cargo linting.
+
+- **testing** (Workflow 4): Updates to multiple UI test files in `tests/ui/` for the `format_push_string` lint, including new tests for suggestion behavior under various configurations (no_std, unfixable cases) and updated expected outputs (`.stderr`, `.fixed`).
+
+- **lint-development** (Workflow 5): The PR is a direct instance of lint development, modifying an existing lint's logic to add suggestion support, updating manual registration in `lib.rs` to use stateful pass construction, and maintaining corresponding UI tests.
+
+## cargo-clippy Analysis
+### Summary of design changes
+Specific aspects affected: The registration and execution of lint passes in the compilation pipeline. The PR updates the constructor for `FormatPushString` pass to include `FormatArgsStorage`, enabling advanced detection of `format!` macro calls for generating targeted suggestions. This is implemented within `register_lint_passes` by cloning the shared storage into the pass. Potential benefits: Improved lint accuracy and user-friendly fixes, reducing unnecessary String allocations in formatted string concatenation. Implications: Enhanced diagnostic quality in project-wide linting runs.
+
+The design diagram's registration step has been updated to note internal resource initialization and stateful pass creation.
+
+```mermaid
+sequenceDiagram
+    participant LS as "Lint Store"
+    participant CL as "Clippy Lints"
+    Note over LS,CL: Diff visualization
+    Note over CL: Addition (green rect)
+    CL->>CL: initialize FormatArgsStorage
+    Note over LS: Change (yellow rect)
+    LS->>CL: register_lint_passes
+    CL-->>LS: register stateful passes (e.g., format_push_string with storage)
+```
+ (Green: new internal step; Yellow: modified pass registration to support state.)
+
+## clippy-driver Analysis
+### Summary of design changes
+Similar to cargo-clippy, the PR affects the lint pass registration in the driver's compiler callbacks. The updated pass can now provide suggestions during direct compilations. Implemented by the same code changes in clippy_lints. Benefits: Consistent improvements across invocation methods. The design diagram updated accordingly.
+
+```mermaid
+sequenceDiagram
+    participant C as Compiler Config & Callbacks
+    participant LS as Lint Store
+    Note over C,LS: Existing
+    C->>LS: register_lint_passes()
+    Note over C,LS: After PR
+    Note over LS: Change (yellow): adds stateful lints
+    C->>LS: register_lint_passes() - with shared resources init
+```
+ (Yellow: updated description to include resource handling.)
+
+## testing Analysis
+### Summary of design changes
+The PR updates 11 test files to match the new diagnostic outputs, including addition of `.fixed` files for testing auto-fix applicability and new test cases for edge cases (e.g., no_std_unfixable). This validates the lint's new suggestion logic without changing the UI test execution flow or components. Implemented by updating expected `.stderr` with new messages, labels, notes, and fix results. Benefits: Ensures regression-free enhancements and full coverage of new features. No mermaid diagram updates needed, as the sequence remains the same.
+
+## lint-development Analysis
+### Summary of design changes
+The PR modifies the documented design by exemplifying and prompting documentation of stateful lint passes using shared `FormatArgsStorage` for macro analysis. Specific aspects: Lint implementation now includes state in pass struct for efficiency, registration manually passes cloned storage. New detection logic spans nested expressions via recursive search. Suggestions use `span_suggestion_verbose` with `Applicability::MaybeIncorrect` and dynamic paths via `std_or_core`. The design doc has been updated with a new bullet in "Lint Implementation Details" and enhanced integration diagram to show resource preparation and stateful extension. Benefits: Enables complex analysis patterns for lints, improves suggestion completeness for `format_push_string`. Implications: Developers can adopt this pattern for other macro-heavy lints.
+
+Updated mermaid diagram in doc shows additions/changes; diff visualization:
+
+```mermaid
+sequenceDiagram
+    participant Driver
+    participant LintsCrate
+    participant Store
+    Driver->>LintsCrate: call register_lint_passes on store
+    Note over LintsCrate: Addition (green)
+    LintsCrate->>LintsCrate: initialize FormatArgsStorage
+    Note over Store: Change (yellow)
+    LintsCrate->>Store: extend passes (with storage for some lints like format_push_string)
+```
+ (Green: new resource init step; Yellow: modified extension to include state passing.)
+
+The PR does not affect other workflows' designs significantly.