Use marker trait for finding ink! storage struct during code analysis (#2499)

* Use marker trait for finding ink! storage struct during code analysis

* Update changelog

* chore: fix `6.0.0-alpha` headings

Author: davidsemakula

CHANGELOG.md

@@ -6,6 +6,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 [Unreleased]
 
+### Changed
+
+- Use marker trait for finding ink! storage `struct` during code analysis - [2499](https://github.com/use-ink/ink/pull/2499)
+
 ## Version 6.0.0-alpha
 
 This is our first alpha release for ink! v6. We release it together
@@ -210,12 +214,12 @@ As before, it functions as a simple local development node.
 It contains `pallet-revive` in a default configuration.
 You can find binary releases of the node [here](https://github.com/use-ink/ink-node/releases).
 
-## Changed
+### Changed
 - Restrict which `cfg` attributes can be used ‒ [#2313](https://github.com/use-ink/ink/pull/2313)
 - More idiomatic return types for metadata getters - [#2398](https://github.com/use-ink/ink/pull/2398)
 - Define static distributed events slice in `ink` crate - [#2487](https://github.com/use-ink/ink/pull/2487)
 
-## Added
+### Added
 - Support for `caller_is_root` - [#2332](https://github.com/use-ink/ink/pull/2332)
 - Allow setting features for contract build in E2E tests - [#2460](https://github.com/use-ink/ink/pull/2460)
 - Improve support for Solidity ABI calling conventions - [#2411](https://github.com/use-ink/ink/pull/2411)
@@ -224,7 +228,7 @@ You can find binary releases of the node [here](https://github.com/use-ink/ink-n
 - Documentation for contract abi arg and provided Rust/ink! to Solidity type mappings - [2463](https://github.com/use-ink/ink/pull/2463)
 - Implement `SolDecode`, `SolTypeDecode` and support `SolBytes` for boxed slices - [2476](https://github.com/use-ink/ink/pull/2476)
 
-## Fixed
+### Fixed
 - [E2E] Have port parsing handle comma-separated list ‒ [#2336](https://github.com/use-ink/ink/pull/2336)
 - Always use ink! ABI/ SCALE codec for constructor and instantiation related builders and utilities - [#2474](https://github.com/use-ink/ink/pull/2474)
 - Get rid of "extrinsic for call failed: Pallet error: Revive::AccountAlreadyMapped" - [2483](https://github.com/use-ink/ink/pull/2483)

crates/ink/codegen/src/generator/storage.rs

@@ -81,13 +81,16 @@ impl Storage<'_> {
     ///
     /// # Developer Note
     ///
-    /// The `fortanix` config attribute is used here to convey the
-    /// information that the generated struct is an ink! storage struct to `dylint`.
+    /// The `__ink_StorageMarker` trait marks the generated `struct` as an ink! storage
+    /// `struct`.
     ///
-    /// We decided on this attribute to mark the function, as it has to be a
-    /// key-value pair that is well known to `cargo`. `fortanix` seems like an obscure
-    /// vendor, for  which it is highly unlikely that someone will ever compile
-    /// a contract for.
+    /// This marker trait can be used to find the ink! storage struct during code analysis
+    /// stages of the compilation pipeline (e.g. in the `ink_linting` infrastructure).
+    ///
+    /// This approach is similar to Rust's use of [marker][rust-markers] traits
+    /// to express that a type satisfies some property.
+    ///
+    /// [rust-markers]: https://doc.rust-lang.org/std/marker/index.html
     fn generate_storage_struct(&self) -> TokenStream2 {
         let storage = self.contract.module().storage();
         let span = storage.span();
@@ -99,7 +102,6 @@ impl Storage<'_> {
             #(#attrs)*
             #[::ink::storage_item]
             #[cfg_attr(test, derive(::core::fmt::Debug))]
-            #[cfg(not(target_vendor = "fortanix"))]
             pub struct #ident #generics {
                 #( #fields ),*
             }
@@ -108,6 +110,10 @@ impl Storage<'_> {
                 impl ::ink::reflect::ContractName for #ident {
                     const NAME: &'static str = ::core::stringify!(#ident);
                 }
+
+                #[allow(non_camel_case_types)]
+                trait __ink_StorageMarker {}
+                impl __ink_StorageMarker for #ident {}
             };
         )
     }

linting/utils/src/lib.rs

@@ -35,6 +35,11 @@ pub use parity_clippy_utils as clippy;
 use clippy::match_def_path;
 use if_chain::if_chain;
 use rustc_hir::{
+    def::DefKind,
+    def_id::{
+        DefId,
+        LOCAL_CRATE,
+    },
     ExprKind,
     HirId,
     ItemId,
@@ -45,11 +50,39 @@ use rustc_hir::{
     TyKind,
 };
 use rustc_lint::LateContext;
+use rustc_middle::ty::{
+    fast_reject::SimplifiedType,
+    TyCtxt,
+};
+
+/// Returns `DefId` of the `__ink_StorageMarker` marker trait (if any).
+///
+/// # Developer Note
+///
+/// In ink! 6.0.0, our code generation implements the marker trait `__ink_StorageMarker`
+/// for the `#[ink(storage)]` annotated `struct`.
+///
+/// This marker trait can be used to find the ink! storage struct.
+///
+/// This approach is similar to Rust's use of [marker][rust-markers] traits
+/// to express that a type satisfies some property.
+///
+/// [rust-markers]: https://doc.rust-lang.org/std/marker/index.html
+fn storage_marker_trait(tcx: TyCtxt) -> Option<&DefId> {
+    tcx.traits(LOCAL_CRATE).iter().find(|trait_def_id| {
+        tcx.item_name(**trait_def_id).as_str() == "__ink_StorageMarker"
+    })
+}
 
 /// Returns `true` iff the ink storage attribute is defined for the given HIR
 ///
 /// # Developer Note
 ///
+/// **IMPORTANT**: The description below doesn't apply to ink! 6.0.0,
+/// because this mechanism is now replaced with the more idiomatic approach
+/// of using a "marker" trait to identify the ink! storage `struct`
+/// (see [`storage_marker_trait`] for details).
+///
 /// In ink! 5.0.0 our code generation added the annotation
 /// `#[cfg(not(feature = "__ink_dylint_Storage"))] to contracts. This
 /// allowed dylint to identify the storage struct in a contract.
@@ -74,20 +107,55 @@ fn has_storage_attr(cx: &LateContext, hir: HirId) -> bool {
     attrs.contains(INK_STORAGE_1) || attrs.contains(INK_STORAGE_2)
 }
 
+/// Returns `DefId` of the `struct` annotated with `#[ink(storage)]` (if any).
+///
+/// See [`storage_marker_trait`].
+pub fn find_storage_struct_def(tcx: TyCtxt) -> Option<&DefId> {
+    let storage_marker_trait_id = storage_marker_trait(tcx)?;
+    let storage_marker_impls = tcx
+        .trait_impls_of(storage_marker_trait_id)
+        .non_blanket_impls();
+    debug_assert_eq!(
+        storage_marker_impls.len(),
+        1,
+        "Expected exactly one implementation of the `__ink_StorageMarker` marker trait"
+    );
+    let (storage_ty, _) = storage_marker_impls.first()?;
+    let SimplifiedType::Adt(adt_def_id) = storage_ty else {
+        return None;
+    };
+    matches!(tcx.def_kind(adt_def_id), DefKind::Struct).then_some(adt_def_id)
+}
+
 /// Returns `ItemId` of the structure annotated with `#[ink(storage)]`
 pub fn find_storage_struct(cx: &LateContext, item_ids: &[ItemId]) -> Option<ItemId> {
-    item_ids
-        .iter()
-        .find(|&item_id| {
-            let item = cx.tcx.hir_item(*item_id);
-            if_chain! {
-                if has_storage_attr(cx, item.hir_id());
-                if let ItemKind::Struct(..) = item.kind;
-                then { true } else { false }
-
+    let tcx = cx.tcx;
+    // Finds storage item using `__ink_StorageMarker` marker trait for ink! 6.0.0
+    // (see [`storage_marker_trait`] for details).
+    let storage_item_id = find_storage_struct_def(tcx)
+        .and_then(|def_id| def_id.as_local())
+        .map(|local_def_id| tcx.local_def_id_to_hir_id(local_def_id))
+        .map(|hir_id| {
+            // See `Item::hir_id` for reverse operation.
+            ItemId {
+                owner_id: hir_id.owner,
             }
-        })
-        .copied()
+        });
+    storage_item_id.or_else(|| {
+        // Fallback for ink! 5.0.0 (see [`has_storage_attr`] for details).
+        item_ids
+            .iter()
+            .find(|&item_id| {
+                let item = cx.tcx.hir_item(*item_id);
+                if_chain! {
+                    if has_storage_attr(cx, item.hir_id());
+                    if let ItemKind::Struct(..) = item.kind;
+                    then { true } else { false }
+
+                }
+            })
+            .copied()
+    })
 }
 
 /// Returns `ItemId`s defined inside the code block of `const _: () = {}`.