Revert "feat: LazyAccount support for missing_account_reload lint"

meumar-osec · meumar-osec · commit 4867cbf8e88d · 2026-03-06T10:24:22.000+05:30
This reverts commit e897950.
diff --git a/anchor-lints-utils/src/diag_items.rs b/anchor-lints-utils/src/diag_items.rs
@@ -78,8 +78,6 @@ pub enum DiagnoticItem {
     SplTokenAccount,
     /// `spl_token::state::Mint`
     SplTokenMint,
-    /// `anchor_lang::prelude::LazyAccount`
-    AnchorLazyAccount,
 }
 
 impl DiagnoticItem {
@@ -151,9 +149,6 @@ impl DiagnoticItem {
             DiagnoticItem::SplTokenMint => {
                 return None;
             }
-            DiagnoticItem::AnchorLazyAccount => {
-                return None;
-            }
         })
     }
 
@@ -260,7 +255,6 @@ impl DiagnoticItem {
             }
             DiagnoticItem::SplTokenAccount => &["spl_token::state::Account"],
             DiagnoticItem::SplTokenMint => &["spl_token::state::Mint"],
-            DiagnoticItem::AnchorLazyAccount => &["anchor_lang::prelude::LazyAccount"],
         }
     }
 
@@ -469,10 +463,10 @@ pub fn is_solana_instruction_type(tcx: TyCtxt, ty: Ty) -> bool {
 
 pub fn is_box_type(tcx: TyCtxt, ty: Ty) -> bool {
     let ty = ty.peel_refs();
-    if let ty::Adt(adt_def, _) = ty.kind()
-        && let Some(box_def_id) = tcx.lang_items().owned_box()
-    {
-        return adt_def.did() == box_def_id;
+    if let ty::Adt(adt_def, _) = ty.kind() {
+        if let Some(box_def_id) = tcx.lang_items().owned_box() {
+            return adt_def.did() == box_def_id;
+        }
     }
     false
 }
@@ -498,8 +492,3 @@ pub fn is_cpi_builder_constructor_fn(tcx: TyCtxt, def_id: DefId) -> bool {
         || path.contains("UnlockV1")
         || path.contains("RevokeStaking")
 }
-
-pub fn is_anchor_lazy_account_type(tcx: TyCtxt, ty: Ty) -> bool {
-    let ty = ty.peel_refs();
-    DiagnoticItem::AnchorLazyAccount.defid_is_type(tcx, ty)
-}
diff --git a/lints/missing_account_reload/src/lib.rs b/lints/missing_account_reload/src/lib.rs
@@ -10,7 +10,7 @@ use std::collections::{HashMap, HashSet};
 
 use anchor_lints_utils::utils::should_skip_function;
 use anchor_lints_utils::{
-    diag_items::{DiagnoticItem, is_anchor_lazy_account_type, is_cpi_invoke_fn},
+    diag_items::{DiagnoticItem, is_cpi_invoke_fn},
     mir_analyzer::{AnchorContextInfo, MirAnalyzer},
     utils::get_hir_body_from_local_def_id,
 };
@@ -124,25 +124,6 @@ impl<'tcx> LateLintPass<'tcx> for MissingAccountReload {
                         }
                     }
                 }
-                // Check for LazyAccount::load/LazyAccount::load_mut (reloads for LazyAccount)
-                else if let Some(name) = cx.tcx.opt_item_name(*fn_def_id)
-                    && (name.as_str() == "load" || name.as_str() == "load_mut")
-                    && let Some(receiver) = args.first()
-                    && let Operand::Move(place) | Operand::Copy(place) = &receiver.node
-                    && let Some(local) = place.as_local()
-                    && let Some(decl) = mir.local_decls.get(local)
-                {
-                    let receiver_ty = decl.ty.peel_refs();
-                    if is_anchor_lazy_account_type(cx.tcx, receiver_ty)
-                        && let Some(account_name_and_local) =
-                            mir_analyzer.extract_account_name_from_local(&local, false)
-                    {
-                        account_reloads
-                            .entry(account_name_and_local.account_name)
-                            .or_default()
-                            .insert(bb);
-                    }
-                }
                 // Or a CPI invoke function
                 else if is_cpi_invoke_fn(cx.tcx, *fn_def_id)
                     || mir_analyzer.takes_cpi_context(args)
@@ -394,27 +375,6 @@ pub fn analyze_nested_function_operations<'tcx>(
                     nested_function_blocks.push(block);
                 }
             }
-            // Check for LazyAccount::load/LazyAccount::load_mut (reloads for LazyAccount)
-            else if let Some(name) = cx.tcx.opt_item_name(*def_id)
-                && (name.as_str() == "load" || name.as_str() == "load_mut")
-                && let Some(receiver) = args.first()
-                && let Operand::Move(place) | Operand::Copy(place) = &receiver.node
-                && let Some(local) = place.as_local()
-                && let Some(decl) = mir_body.local_decls.get(local)
-            {
-                let receiver_ty = decl.ty.peel_refs();
-                if is_anchor_lazy_account_type(cx.tcx, receiver_ty)
-                    && let Some(block) = handle_account_reload_in_nested_function(
-                        &mir_analyzer,
-                        mir_body,
-                        args,
-                        *fn_span,
-                        bb,
-                    )
-                {
-                    nested_function_blocks.push(block);
-                }
-            }
             // Handle account access (deref) in nested function
             else if cx
                 .tcx
diff --git a/lints/missing_account_reload/src/utils/paths.rs b/lints/missing_account_reload/src/utils/paths.rs
@@ -1,8 +1,8 @@
 use anchor_lints_utils::{
     diag_items::{
         is_account_info_type, is_anchor_account_loader_type, is_anchor_account_type,
-        is_anchor_interface_account_type, is_anchor_lazy_account_type, is_anchor_signer_type,
-        is_anchor_system_account_type, is_anchor_unchecked_account_type, is_box_type,
+        is_anchor_interface_account_type, is_anchor_signer_type, is_anchor_system_account_type,
+        is_anchor_unchecked_account_type, is_box_type,
     },
     mir_analyzer::AnchorContextInfo,
 };
@@ -58,9 +58,7 @@ pub fn contains_deserialized_data<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) ->
         if is_anchor_account_loader_type(cx.tcx, ty) {
             return false;
         }
-        if is_anchor_interface_account_type(cx.tcx, ty)
-            || is_anchor_system_account_type(cx.tcx, ty)
-            || is_anchor_lazy_account_type(cx.tcx, ty)
+        if is_anchor_interface_account_type(cx.tcx, ty) || is_anchor_system_account_type(cx.tcx, ty)
         {
             return true;
         }
diff --git a/lints/missing_account_reload/tests/test_program/Cargo.toml b/lints/missing_account_reload/tests/test_program/Cargo.toml
@@ -9,4 +9,4 @@ workspace = "../../../../tests"
 crate-type = ["cdylib"]
 
 [dependencies]
-anchor-lang = { git = "https://github.com/jamie-osec/anchor", rev = "939b843", features = ["lazy-account"] }
+anchor-lang = { git = "https://github.com/jamie-osec/anchor", rev = "939b843" }
diff --git a/lints/missing_account_reload/tests/test_program/src/lib.rs b/lints/missing_account_reload/tests/test_program/src/lib.rs
@@ -4,7 +4,7 @@ use anchor_lang::solana_program::{
     system_instruction,
 };
 
-use anchor_lang::system_program::{Transfer, transfer};
+use anchor_lang::system_program::{transfer, Transfer};
 
 declare_id!("11111111111111111111111111111111");
 
@@ -319,56 +319,18 @@ pub mod missing_account_reload_tests {
     }
 
     // Pattern 17: CPI call with self implementation - safe
-    pub fn invoke_with_self_implementation_safe(
-        ctx: Context<SolTransfer3>,
-        amount: u64,
-    ) -> Result<()> {
+    pub fn invoke_with_self_implementation_safe(ctx: Context<SolTransfer3>, amount: u64) -> Result<()> {
         ctx.accounts.cpi_call_safe(amount)?;
         let _final_data = ctx.accounts.pda_account.data; // [safe_account_accessed]
         Ok(())
     }
 
     // Pattern 18: CPI call with self implementation - unsafe
-    pub fn invoke_with_self_implementation_unsafe(
-        ctx: Context<SolTransfer3>,
-        amount: u64,
-    ) -> Result<()> {
+    pub fn invoke_with_self_implementation_unsafe(ctx: Context<SolTransfer3>, amount: u64) -> Result<()> {
         ctx.accounts.cpi_call_unsafe(amount)?;
         let _final_data = ctx.accounts.pda_account.data; // [unsafe_account_accessed]
         Ok(())
     }
-
-    /// Patten 19: load_mut() then CPI — unsafe.
-    pub fn test_lazy_account_unsafe(
-        ctx: Context<LazyAccountCpiAccounts>,
-        amount: u64,
-    ) -> Result<()> {
-        let data = ctx.accounts.lazy_acc.load_mut()?; // ref held across CPI
-        let _ = data.value;
-        let new_space = ctx.accounts.lazy_acc.to_account_info().data_len() as u64 + amount;
-        let ix = system_instruction::allocate(&ctx.accounts.lazy_acc.key(), new_space);
-        let account_infos = vec![
-            ctx.accounts.lazy_acc.to_account_info(),
-            ctx.accounts.system_program.to_account_info(),
-        ];
-        invoke(&ix, &account_infos)?; // [cpi_call]
-        let _ = data.value; // [unsafe_account_accessed]
-        Ok(())
-    }
-
-    // Pattern 20: load_mut() then CPI with load_mut() — safe
-    pub fn test_lazy_account_safe(ctx: Context<LazyAccountCpiAccounts>, amount: u64) -> Result<()> {
-        let new_space = ctx.accounts.lazy_acc.to_account_info().data_len() as u64 + amount;
-        let ix = system_instruction::allocate(&ctx.accounts.lazy_acc.key(), new_space);
-        let account_infos = vec![
-            ctx.accounts.lazy_acc.to_account_info(),
-            ctx.accounts.system_program.to_account_info(),
-        ];
-        invoke(&ix, &account_infos)?;
-        let data = ctx.accounts.lazy_acc.load_mut()?;
-        let _ = data.value; // [safe_account_accessed]
-        Ok(())
-    }
 }
 pub fn cpi_call_safe(ctx_a: &mut Context<SolTransfer3>, amount: u64) -> Result<()> {
     let from_pubkey = ctx_a.accounts.pda_account.to_account_info();
@@ -647,18 +609,6 @@ impl<'info> SolTransfer3<'info> {
     }
 }
 
-#[account]
-pub struct LazyLoadable {
-    pub value: u64,
-}
-
-#[derive(Accounts)]
-pub struct LazyAccountCpiAccounts<'info> {
-    #[account(mut)]
-    pub lazy_acc: LazyAccount<'info, LazyLoadable>,
-    pub system_program: Program<'info, System>,
-}
-
 #[account]
 pub struct UserState {
     pub data: u64,

Original file line number	Diff line number	Diff line change
`@@ -78,8 +78,6 @@ pub enum DiagnoticItem {`
`78`	`78`	`SplTokenAccount,`
`79`	`79`	/// `spl_token::state::Mint`
`80`	`80`	`SplTokenMint,`
`81`		- /// `anchor_lang::prelude::LazyAccount`
`82`		`- AnchorLazyAccount,`
`83`	`81`	`}`
`84`	`82`
`85`	`83`	`impl DiagnoticItem {`
`@@ -151,9 +149,6 @@ impl DiagnoticItem {`
`151`	`149`	`DiagnoticItem::SplTokenMint => {`
`152`	`150`	`return None;`
`153`	`151`	`}`
`154`		`- DiagnoticItem::AnchorLazyAccount => {`
`155`		`- return None;`
`156`		`- }`
`157`	`152`	`})`
`158`	`153`	`}`
`159`	`154`
`@@ -260,7 +255,6 @@ impl DiagnoticItem {`
`260`	`255`	`}`
`261`	`256`	`DiagnoticItem::SplTokenAccount => &["spl_token::state::Account"],`
`262`	`257`	`DiagnoticItem::SplTokenMint => &["spl_token::state::Mint"],`
`263`		`- DiagnoticItem::AnchorLazyAccount => &["anchor_lang::prelude::LazyAccount"],`
`264`	`258`	`}`
`265`	`259`	`}`
`266`	`260`
`@@ -469,10 +463,10 @@ pub fn is_solana_instruction_type(tcx: TyCtxt, ty: Ty) -> bool {`
`469`	`463`
`470`	`464`	`pub fn is_box_type(tcx: TyCtxt, ty: Ty) -> bool {`
`471`	`465`	`let ty = ty.peel_refs();`
`472`		`- if let ty::Adt(adt_def, _) = ty.kind()`
`473`		`- && let Some(box_def_id) = tcx.lang_items().owned_box()`
`474`		`- {`
`475`		`- return adt_def.did() == box_def_id;`
	`466`	`+ if let ty::Adt(adt_def, _) = ty.kind() {`
	`467`	`+ if let Some(box_def_id) = tcx.lang_items().owned_box() {`
	`468`	`+ return adt_def.did() == box_def_id;`
	`469`	`+ }`
`476`	`470`	`}`
`477`	`471`	`false`
`478`	`472`	`}`
`@@ -498,8 +492,3 @@ pub fn is_cpi_builder_constructor_fn(tcx: TyCtxt, def_id: DefId) -> bool {`
`498`	`492`	`\|\| path.contains("UnlockV1")`
`499`	`493`	`\|\| path.contains("RevokeStaking")`
`500`	`494`	`}`
`501`		`-`
`502`		`-pub fn is_anchor_lazy_account_type(tcx: TyCtxt, ty: Ty) -> bool {`
`503`		`- let ty = ty.peel_refs();`
`504`		`- DiagnoticItem::AnchorLazyAccount.defid_is_type(tcx, ty)`
`505`		`-}`