How to conditionally compile functions in pallet::call?

Question

I'm trying to have my pallet compile a pallet call based on the feature that is set, for example if I have two function calls feature_one() and feature_two(), it works fine with feature_one but when I add the second method with the #[cfg(feature= "feature2")] macro it gives me the following error:

      error[E0599]: no function or associated item named `feature_two` found for struct `pallet::Pallet` in the current scope

    function or associated item not found in `pallet::Pallet<T>`
    help: there is an associated function with a similar name: `feature_one`

this is the pallet code:

        #![cfg_attr(not(feature = "std"), no_std)]
        #[cfg(test)]
        mod tests;
        pub use pallet::*;
        #[frame_support::pallet]
        pub mod pallet {
            use frame_system::pallet_prelude::*;
            pub use sp_runtime::traits::Extrinsic;
            #[pallet::pallet]
            #[pallet::generate_store(pub(super) trait Store)]
            pub struct Pallet<T>(_);
        
            #[pallet::config]
            pub trait Config: frame_system::Config {
                type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
            }
            #[pallet::event]
            #[pallet::generate_deposit(pub(super) fn deposit_event)]
            pub enum Event<T: Config> {
                /// An Event has been validated
                CustomEvent { event_id: T::Hash },
            }
            #[pallet::error]
            pub enum Error<T> {
                AlreadySymbitted,
            }
       #[pallet::storage]
        pub(super) type MyStorage<T: Config> = StorageMap<_, Blake2_128Concat, T::Hash, T::BlockNumber>;
    
    
            #[pallet::call]
            impl<T: Config> Pallet<T> {
                #[cfg(feature= "feature1")]
                #[pallet::weight(0)]
                pub fn feature_one(_origin: OriginFor<T>, event_id: T::Hash) -> DispatchResult {
                } 
    
               #[cfg(feature= "feature2")]
               #[pallet::weight(0)]
                pub fn feature_two(_origin: OriginFor<T>, event_id: T::Hash) -> DispatchResult {
            
            }
    
        }

Answer 1

There are a few ways to solve this.

You can do like this, with one feature flag for both alternatives.

#[pallet::call]
impl<T: Config> Pallet<T> {
  #[pallet::call_index(0)]
  #[pallet::weight(0)]
  fn f() {
    Self::ff();
  }
}

impl<T: Config> Pallet<T> {
  #[cfg(not(feature = "g"))]
  fn ff() {}

  #[cfg(feature = "g")]
  fn ff() {}
}

or use two independent flags to include a stub when unused:

#[pallet::call]
impl<T: Config> Pallet<T> {
  #[pallet::call_index(0)]
  #[pallet::weight(0)]
  fn f() {
     Self::ff();
  }

  #[pallet::call_index(1)]
  #[pallet::weight(0)]
  fn g() {
     Self::gg();
  }
}

impl<T: Config> Pallet<T> {
  #[cfg(feature = "f")]
  fn ff() {}
  #[cfg(not(feature = "f"))]
  fn ff() { return not enable }

  #[cfg(feature = "g")]
  fn gg() {}
  #[cfg(not(feature = "g"))]
  fn gg() { return not enable }
}

or simply hide the struct behind a feature flag:

#[pallet::call_index(0)]
#[pallet::weight(0)]
fn f(.., params: Params) {
   Self::ff(params);
}

#[cfg(feature = "f")]
struct Params {
  f: u8
}

#[cfg(feature = "g")]
struct Params {
  g: u16
}