//! > Test expansion of Starknet storage logic.

//! > test_runner_name
ExpandContractTestRunner(expect_diagnostics: warnings_only)

//! > cairo_code
#[derive(Drop, starknet::Store, Hash)]
struct OuterType {
    x: u32,
}

// TODO(ilya): update format.
#[starknet::contract]
mod test_contract {
    #[storage]
    struct Storage {
        var_felt252: felt252,
        var_u8: u8,
        var_u16: u16,
        var_u32: u32,
        var_u64: u64,
        var_u128: u128,
        var_bool: bool,
        felt252_to_u128: LegacyMap<felt252, u128>,
        u128_to_bool: LegacyMap<u128, bool>,
        bool_to_felt252: LegacyMap<bool, felt252>,
        outer_type_var: super::OuterType,
        outer_type_to_outer_type: LegacyMap<super::OuterType, super::OuterType>,
        inner_type_var: inner::InnerType,
        inner_type_to_inner_type: LegacyMap<inner::InnerType, inner::InnerType>,
    }

    mod inner {
        #[derive(Drop, starknet::Store, Hash)]
        struct InnerType {
            x: u32,
        }
    }
}

//! > generated_cairo_code
lib.cairo:

#[derive(Drop, starknet::Store, Hash)]
struct OuterType {
    x: u32,
}

// TODO(ilya): update format.
#[starknet::contract]
mod test_contract {
    #[storage]
    struct Storage {
        var_felt252: felt252,
        var_u8: u8,
        var_u16: u16,
        var_u32: u32,
        var_u64: u64,
        var_u128: u128,
        var_bool: bool,
        felt252_to_u128: LegacyMap<felt252, u128>,
        u128_to_bool: LegacyMap<u128, bool>,
        bool_to_felt252: LegacyMap<bool, felt252>,
        outer_type_var: super::OuterType,
        outer_type_to_outer_type: LegacyMap<super::OuterType, super::OuterType>,
        inner_type_var: inner::InnerType,
        inner_type_to_inner_type: LegacyMap<inner::InnerType, inner::InnerType>,
    }

    mod inner {
        #[derive(Drop, starknet::Store, Hash)]
        struct InnerType {
            x: u32,
        }
    }
}

lib.cairo:1:1
#[derive(Drop, starknet::Store, Hash)]
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
impls:

impl OuterTypeDrop<> of core::traits::Drop::<OuterType>;
impl OuterTypeHash<
    __State,
    impl __SHashState: core::hash::HashStateTrait<__State>,
    +core::traits::Drop<__State>
> of core::hash::Hash<OuterType, __State, __SHashState> {
    #[inline(always)]
    fn update_state(state: __State, value: OuterType) -> __State {
        let __hash_derive_state = state;
        let x = core::internal::InferDrop::<u32> { value: value.x };
        let __hash_derive_state = core::hash::Hash::<u32>::update_state(__hash_derive_state, x.value);
        __hash_derive_state
    }
}


lib.cairo:1:16
#[derive(Drop, starknet::Store, Hash)]
               ^^^^^^^^^^^^^^^
starknet_derive:

impl OuterTypeStore<> of starknet::Store::<OuterType> {
    fn read(address_domain: u32, base: starknet::storage_access::StorageBaseAddress) -> starknet::SyscallResult<OuterType> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let x = core::internal::InferDestruct::<u32> { value: starknet::Store::<u32>::read(__store_derive_address_domain__, __store_derive_base__)? };
        starknet::SyscallResult::Ok(
            OuterType {
                x: x.value,
            }
        )
    }
    fn write(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, value: OuterType) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let OuterType {
            x,
        } = value;
        let x = core::internal::InferDestruct::<u32> { value: x };
        starknet::Store::<u32>::write(__store_derive_address_domain__, __store_derive_base__, x.value)?;
        starknet::SyscallResult::Ok(())
    }
    fn read_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8) -> starknet::SyscallResult<OuterType> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let x = core::internal::InferDestruct::<u32> { value: starknet::Store::<u32>::read_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__)? };
        starknet::SyscallResult::Ok(
            OuterType {
                x: x.value,
            }
        )
    }
    #[inline(always)]
    fn write_at_offset(address_domain: u32, base: starknet::storage_access::StorageBaseAddress, offset: u8, value: OuterType) -> starknet::SyscallResult<()> {
        let __store_derive_address_domain__ = address_domain;
        let __store_derive_base__ = base;
        let __store_derive_offset__ = offset;
        let OuterType {
            x,
        } = value;
        let x = core::internal::InferDestruct::<u32> { value: x };
        starknet::Store::<u32>::write_at_offset(__store_derive_address_domain__, __store_derive_base__, __store_derive_offset__, x.value)?;
        starknet::SyscallResult::Ok(())
    }
    #[inline(always)]
    fn size() -> u8 {
        starknet::Store::<u32>::size()
    }
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct OuterTypeSubPointers {
    pub x: starknet::storage::StoragePointer<u32>,
}
#[doc(hidden)]
impl OuterTypeSubPointersImpl of starknet::storage::SubPointers<OuterType> {
    type SubPointersType = OuterTypeSubPointers;
    fn sub_pointers(self: starknet::storage::StoragePointer<OuterType>) -> OuterTypeSubPointers {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __x_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                OuterTypeSubPointers {
           x: __x_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct OuterTypeSubPointersMut {
    pub x: starknet::storage::StoragePointer<starknet::storage::Mutable::<u32>>,
}
#[doc(hidden)]
impl OuterTypeSubPointersMutImpl of starknet::storage::SubPointersMut<OuterType> {
    type SubPointersType = OuterTypeSubPointersMut;
    fn sub_pointers_mut(self: starknet::storage::StoragePointer<starknet::storage::Mutable::<OuterType>>) -> OuterTypeSubPointersMut {
        let base_address = self.__storage_pointer_address__;
        let mut current_offset = self.__storage_pointer_offset__;
        let __x_value__ = starknet::storage::StoragePointer {
            __storage_pointer_address__: base_address,
            __storage_pointer_offset__: current_offset,
        };
                OuterTypeSubPointersMut {
           x: __x_value__,
        }
    }
}


lib.cairo:1:16
#[derive(Drop, starknet::Store, Hash)]
               ^^^^^^^^^^^^^^^
impls:

#[doc(hidden)]
impl OuterTypeSubPointersDrop<> of core::traits::Drop::<OuterTypeSubPointers>;
#[doc(hidden)]
impl OuterTypeSubPointersCopy<> of core::traits::Copy::<OuterTypeSubPointers>;


lib.cairo:1:16
#[derive(Drop, starknet::Store, Hash)]
               ^^^^^^^^^^^^^^^
impls:

#[doc(hidden)]
impl OuterTypeSubPointersMutDrop<> of core::traits::Drop::<OuterTypeSubPointersMut>;
#[doc(hidden)]
impl OuterTypeSubPointersMutCopy<> of core::traits::Copy::<OuterTypeSubPointersMut>;


lib.cairo:7:1
#[starknet::contract]
^^^^^^^^^^^^^^^^^^^^^
contract:

#[event]
#[derive(Drop, starknet::Event)]
pub enum Event {}


#[phantom]
pub struct Storage {
        pub var_felt252: felt252,
        pub var_u8: u8,
        pub var_u16: u16,
        pub var_u32: u32,
        pub var_u64: u64,
        pub var_u128: u128,
        pub var_bool: bool,
        pub felt252_to_u128: LegacyMap<felt252, u128>,
        pub u128_to_bool: LegacyMap<u128, bool>,
        pub bool_to_felt252: LegacyMap<bool, felt252>,
        pub outer_type_var: super::OuterType,
        pub outer_type_to_outer_type: LegacyMap<super::OuterType, super::OuterType>,
        pub inner_type_var: inner::InnerType,
        pub inner_type_to_inner_type: LegacyMap<inner::InnerType, inner::InnerType>,
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct StorageStorageBase {
    pub var_felt252: starknet::storage::StorageBase<felt252>,
    pub var_u8: starknet::storage::StorageBase<u8>,
    pub var_u16: starknet::storage::StorageBase<u16>,
    pub var_u32: starknet::storage::StorageBase<u32>,
    pub var_u64: starknet::storage::StorageBase<u64>,
    pub var_u128: starknet::storage::StorageBase<u128>,
    pub var_bool: starknet::storage::StorageBase<bool>,
    pub felt252_to_u128: starknet::storage::StorageBase<LegacyMap<felt252, u128>>,
    pub u128_to_bool: starknet::storage::StorageBase<LegacyMap<u128, bool>>,
    pub bool_to_felt252: starknet::storage::StorageBase<LegacyMap<bool, felt252>>,
    pub outer_type_var: starknet::storage::StorageBase<super::OuterType>,
    pub outer_type_to_outer_type: starknet::storage::StorageBase<LegacyMap<super::OuterType, super::OuterType>>,
    pub inner_type_var: starknet::storage::StorageBase<inner::InnerType>,
    pub inner_type_to_inner_type: starknet::storage::StorageBase<LegacyMap<inner::InnerType, inner::InnerType>>,
}
#[doc(hidden)]
impl StorageStorageImpl of starknet::storage::StorageTrait<Storage> {
    type BaseType = StorageStorageBase;
    fn storage(self: starknet::storage::FlattenedStorage<Storage>) -> StorageStorageBase {
        let __var_felt252_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_felt252")};
        let __var_u8_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_u8")};
        let __var_u16_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_u16")};
        let __var_u32_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_u32")};
        let __var_u64_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_u64")};
        let __var_u128_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_u128")};
        let __var_bool_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_bool")};
        let __felt252_to_u128_value__ = starknet::storage::StorageBase {__base_address__: selector!("felt252_to_u128")};
        let __u128_to_bool_value__ = starknet::storage::StorageBase {__base_address__: selector!("u128_to_bool")};
        let __bool_to_felt252_value__ = starknet::storage::StorageBase {__base_address__: selector!("bool_to_felt252")};
        let __outer_type_var_value__ = starknet::storage::StorageBase {__base_address__: selector!("outer_type_var")};
        let __outer_type_to_outer_type_value__ = starknet::storage::StorageBase {__base_address__: selector!("outer_type_to_outer_type")};
        let __inner_type_var_value__ = starknet::storage::StorageBase {__base_address__: selector!("inner_type_var")};
        let __inner_type_to_inner_type_value__ = starknet::storage::StorageBase {__base_address__: selector!("inner_type_to_inner_type")};
        StorageStorageBase {
           var_felt252: __var_felt252_value__,
           var_u8: __var_u8_value__,
           var_u16: __var_u16_value__,
           var_u32: __var_u32_value__,
           var_u64: __var_u64_value__,
           var_u128: __var_u128_value__,
           var_bool: __var_bool_value__,
           felt252_to_u128: __felt252_to_u128_value__,
           u128_to_bool: __u128_to_bool_value__,
           bool_to_felt252: __bool_to_felt252_value__,
           outer_type_var: __outer_type_var_value__,
           outer_type_to_outer_type: __outer_type_to_outer_type_value__,
           inner_type_var: __inner_type_var_value__,
           inner_type_to_inner_type: __inner_type_to_inner_type_value__,
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct StorageStorageBaseMut {
    pub var_felt252: starknet::storage::StorageBase<starknet::storage::Mutable::<felt252>>,
    pub var_u8: starknet::storage::StorageBase<starknet::storage::Mutable::<u8>>,
    pub var_u16: starknet::storage::StorageBase<starknet::storage::Mutable::<u16>>,
    pub var_u32: starknet::storage::StorageBase<starknet::storage::Mutable::<u32>>,
    pub var_u64: starknet::storage::StorageBase<starknet::storage::Mutable::<u64>>,
    pub var_u128: starknet::storage::StorageBase<starknet::storage::Mutable::<u128>>,
    pub var_bool: starknet::storage::StorageBase<starknet::storage::Mutable::<bool>>,
    pub felt252_to_u128: starknet::storage::StorageBase<starknet::storage::Mutable::<LegacyMap<felt252, u128>>>,
    pub u128_to_bool: starknet::storage::StorageBase<starknet::storage::Mutable::<LegacyMap<u128, bool>>>,
    pub bool_to_felt252: starknet::storage::StorageBase<starknet::storage::Mutable::<LegacyMap<bool, felt252>>>,
    pub outer_type_var: starknet::storage::StorageBase<starknet::storage::Mutable::<super::OuterType>>,
    pub outer_type_to_outer_type: starknet::storage::StorageBase<starknet::storage::Mutable::<LegacyMap<super::OuterType, super::OuterType>>>,
    pub inner_type_var: starknet::storage::StorageBase<starknet::storage::Mutable::<inner::InnerType>>,
    pub inner_type_to_inner_type: starknet::storage::StorageBase<starknet::storage::Mutable::<LegacyMap<inner::InnerType, inner::InnerType>>>,
}
#[doc(hidden)]
impl StorageStorageMutImpl of starknet::storage::StorageTraitMut<Storage> {
    type BaseType = StorageStorageBaseMut;
    fn storage_mut(self: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<Storage>>) -> StorageStorageBaseMut {
        let __var_felt252_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_felt252")};
        let __var_u8_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_u8")};
        let __var_u16_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_u16")};
        let __var_u32_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_u32")};
        let __var_u64_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_u64")};
        let __var_u128_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_u128")};
        let __var_bool_value__ = starknet::storage::StorageBase {__base_address__: selector!("var_bool")};
        let __felt252_to_u128_value__ = starknet::storage::StorageBase {__base_address__: selector!("felt252_to_u128")};
        let __u128_to_bool_value__ = starknet::storage::StorageBase {__base_address__: selector!("u128_to_bool")};
        let __bool_to_felt252_value__ = starknet::storage::StorageBase {__base_address__: selector!("bool_to_felt252")};
        let __outer_type_var_value__ = starknet::storage::StorageBase {__base_address__: selector!("outer_type_var")};
        let __outer_type_to_outer_type_value__ = starknet::storage::StorageBase {__base_address__: selector!("outer_type_to_outer_type")};
        let __inner_type_var_value__ = starknet::storage::StorageBase {__base_address__: selector!("inner_type_var")};
        let __inner_type_to_inner_type_value__ = starknet::storage::StorageBase {__base_address__: selector!("inner_type_to_inner_type")};
        StorageStorageBaseMut {
           var_felt252: __var_felt252_value__,
           var_u8: __var_u8_value__,
           var_u16: __var_u16_value__,
           var_u32: __var_u32_value__,
           var_u64: __var_u64_value__,
           var_u128: __var_u128_value__,
           var_bool: __var_bool_value__,
           felt252_to_u128: __felt252_to_u128_value__,
           u128_to_bool: __u128_to_bool_value__,
           bool_to_felt252: __bool_to_felt252_value__,
           outer_type_var: __outer_type_var_value__,
           outer_type_to_outer_type: __outer_type_to_outer_type_value__,
           inner_type_var: __inner_type_var_value__,
           inner_type_to_inner_type: __inner_type_to_inner_type_value__,
        }
    }
}

pub struct ContractState {
}

impl ContractStateDrop of Drop<ContractState> {}

impl ContractStateDeref of core::ops::Deref<@ContractState> {
    type Target = starknet::storage::FlattenedStorage<Storage>;
    fn deref(self: @ContractState) -> starknet::storage::FlattenedStorage<Storage> {
        starknet::storage::FlattenedStorage {}
    }
}
impl ContractStateDerefMut of core::ops::DerefMut<ContractState> {
    type Target = starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> ;
    fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> {
        starknet::storage::FlattenedStorage {}
    }
}
pub fn unsafe_new_contract_state() -> ContractState {
    ContractState {
    }
}
#[cfg(target: 'test')]
#[inline(always)]
pub fn contract_state_for_testing() -> ContractState {
    unsafe_new_contract_state()
}

// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one.
#[deprecated(
    feature: "deprecated_legacy_map",
    note: "Use `starknet::storage::Map` instead."
)]
#[allow(unused_imports)]
use starknet::storage::Map as LegacyMap;
#[cfg(target: 'test')]
pub const TEST_CLASS_HASH: starknet::ClassHash = 0x25c680547752cece853ea35e00dbd269ee33545db32a2d900eb20e872e0d255.try_into().unwrap();


#[doc(hidden)]
pub mod __external {
}
#[doc(hidden)]
pub mod __l1_handler {
}
#[doc(hidden)]
pub mod __constructor {
}
    impl ContractStateEventEmitter of starknet::event::EventEmitter<
        ContractState, Event
    > {
        fn emit<S, impl IntoImp: core::traits::Into<S, Event>>(
            ref self: ContractState, event: S
        ) {
            let event: Event = core::traits::Into::into(event);
            let mut keys = Default::<core::array::Array>::default();
            let mut data = Default::<core::array::Array>::default();
            starknet::Event::append_keys_and_data(@event, ref keys, ref data);
            starknet::SyscallResultTrait::unwrap_syscall(
                starknet::syscalls::emit_event_syscall(
                    core::array::ArrayTrait::span(@keys),
                    core::array::ArrayTrait::span(@data),
                )
            )
        }
    }



lib.cairo:7:1
#[starknet::contract]
^^^^^^^^^^^^^^^^^^^^^
impls:

impl EventDrop<> of core::traits::Drop::<Event>;


lib.cairo:7:1
#[starknet::contract]
^^^^^^^^^^^^^^^^^^^^^
starknet_derive:

impl EventIsEvent of starknet::Event<Event> {
    fn append_keys_and_data(
        self: @Event, ref keys: Array<felt252>, ref data: Array<felt252>
    ) {
        match self {
        }
    }
    fn deserialize(
        ref keys: Span<felt252>, ref data: Span<felt252>,
    ) -> Option<Event> {
        let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?;
        Option::None
    }
}



lib.cairo:9:5
    #[storage]
    ^^^^^^^^^^
impls:

#[doc(hidden)]
impl StorageStorageBaseDrop<> of core::traits::Drop::<StorageStorageBase>;
#[doc(hidden)]
impl StorageStorageBaseCopy<> of core::traits::Copy::<StorageStorageBase>;


lib.cairo:9:5
    #[storage]
    ^^^^^^^^^^
impls:

#[doc(hidden)]
impl StorageStorageBaseMutDrop<> of core::traits::Drop::<StorageStorageBaseMut>;
#[doc(hidden)]
impl StorageStorageBaseMutCopy<> of core::traits::Copy::<StorageStorageBaseMut>;

//! > expected_diagnostics
warning: Usage of deprecated feature `"deprecated_legacy_map"` with no `#[feature("deprecated_legacy_map")]` attribute. Note: "Use `starknet::storage::Map` instead."
 --> lib.cairo:18:26
        felt252_to_u128: LegacyMap<felt252, u128>,
                         ^^^^^^^^^

warning: Usage of deprecated feature `"deprecated_legacy_map"` with no `#[feature("deprecated_legacy_map")]` attribute. Note: "Use `starknet::storage::Map` instead."
 --> lib.cairo:19:23
        u128_to_bool: LegacyMap<u128, bool>,
                      ^^^^^^^^^

warning: Usage of deprecated feature `"deprecated_legacy_map"` with no `#[feature("deprecated_legacy_map")]` attribute. Note: "Use `starknet::storage::Map` instead."
 --> lib.cairo:20:26
        bool_to_felt252: LegacyMap<bool, felt252>,
                         ^^^^^^^^^

warning: Usage of deprecated feature `"deprecated_legacy_map"` with no `#[feature("deprecated_legacy_map")]` attribute. Note: "Use `starknet::storage::Map` instead."
 --> lib.cairo:22:35
        outer_type_to_outer_type: LegacyMap<super::OuterType, super::OuterType>,
                                  ^^^^^^^^^

warning: Usage of deprecated feature `"deprecated_legacy_map"` with no `#[feature("deprecated_legacy_map")]` attribute. Note: "Use `starknet::storage::Map` instead."
 --> lib.cairo:24:35
        inner_type_to_inner_type: LegacyMap<inner::InnerType, inner::InnerType>,
                                  ^^^^^^^^^
