feat: Emit error if contract macro is above entry_points

.github/workflows/ci.yml

@@ -101,6 +101,45 @@ jobs:
           path: |
             examples/contracts/**/schema/*.json
 
+  # Errors differ between Rust versions. We test only the latest output.
+  test_ui:
+    name: Test UI
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - build: macOS
+            os: macOS-latest
+          - build: Windows
+            os: windows-latest
+    defaults:
+      run:
+        shell: bash
+        working-directory: ./
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v2
+      - name: Cache
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo/bin/
+            ~/.cargo/registry/index/
+            ~/.cargo/registry/cache/
+            ~/.cargo/git/db/
+            target/
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+      - name: Install Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          target: wasm32-unknown-unknown
+          profile: minimal
+          override: true
+      - name: Test project
+        run: cargo test --locked -- --ignored
+
   coverage:
     name: Code coverage
     runs-on: ubuntu-latest

sylvia-derive/src/input.rs

@@ -1,4 +1,4 @@
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use proc_macro_error::{emit_error, emit_warning};
 use quote::quote;
 use syn::{GenericParam, Ident, ItemImpl, ItemTrait, TraitItem};
@@ -7,13 +7,13 @@
 use crate::executor::{ContractExecutor, InterfaceExecutor};
 use crate::interfaces::Interfaces;
 use crate::message::{
-    ContractApi, ContractEnumMessage, EnumMessage, GlueMessage, InterfaceApi, MsgVariants,
-    StructMessage,
+    ContractApi, ContractEnumMessage, EntryPoints, EnumMessage, GlueMessage, InterfaceApi,
+    MsgVariants, StructMessage,
 };
 use crate::multitest::{ContractMtHelpers, TraitMtHelpers};
 use crate::parser::attributes::msg::MsgType;
 use crate::parser::{
-    assert_new_method_defined, ContractErrorAttr, Custom, OverrideEntryPoint,
+    assert_new_method_defined, ContractErrorAttr, Custom, EntryPointArgs, OverrideEntryPoint,
     ParsedSylviaAttributes,
 };
 use crate::querier::{ContractQuerier, InterfaceQuerier};
@@ -339,3 +339,39 @@
         ContractMtHelpers::new(item, generic_params, custom, override_entry_points.clone()).emit()
     }
 }
+
+pub struct EntryPointInput<'a> {
+    item: &'a ItemImpl,
+    args: EntryPointArgs,
+}
+
+impl<'a> EntryPointInput<'a> {
+    pub fn new(item: &'a ItemImpl, args: EntryPointArgs, attr_span: Span) -> Self {
+        let instantiate =
+            MsgVariants::<GenericParam>::new(item.as_variants(), MsgType::Instantiate, &[], &None);
+
+        if args.generics.len() != item.generics.params.len() {
+            emit_error!(
+                attr_span,
+                "Missing concrete types.";
+                note = "For every generic type in the contract, a concrete type must be provided in `#[entry_points(generics<T1, T2, ...>)]`.";
+            );
+        }
+
+        if instantiate.get_only_variant().is_none() {
+            emit_error!(
+                attr_span, "Missing instantiation message.";
+                note = "`sylvia::entry_points` requires exactly one method marked with `#[sv::msg(instantiation)]` attribute.";
+                note = "Make sure you implemented the `entry_points` macro above the `contract` macro."
+            );
+        }
+
+        Self { item, args }
+    }
+
+    pub fn process(&self) -> TokenStream {
+        let Self { item, args } = self;
+
+        EntryPoints::new(item, args).emit()
+    }
+}

sylvia-derive/src/lib.rs

@@ -2,12 +2,15 @@
 //!
 //! Please refer to the [Sylvia-book](https://cosmwasm.github.io/sylvia-book/index.html) on how to use these macros.
 
-use input::{ImplInput, TraitInput};
+use crate::parser::EntryPointArgs;
+use input::{EntryPointInput, ImplInput, TraitInput};
 use proc_macro::TokenStream;
 use proc_macro2::TokenStream as TokenStream2;
 use proc_macro_error::proc_macro_error;
 use quote::quote;
+use strip_input::StripInput;
 use syn::fold::Fold;
+use syn::spanned::Spanned;
 use syn::{parse2, parse_quote, ItemImpl, ItemTrait, Path};
 
 mod associated_types;
@@ -26,11 +29,6 @@
 mod utils;
 mod variant_descs;
 
-use strip_input::StripInput;
-
-use crate::message::EntryPoints;
-use crate::parser::EntryPointArgs;
-
 #[cfg(not(test))]
 pub(crate) fn crate_module() -> Path {
     use proc_macro_crate::{crate_name, FoundCrate};
@@ -759,8 +757,8 @@
 fn entry_points_impl(attr: TokenStream2, item: TokenStream2) -> TokenStream2 {
     fn inner(attr: TokenStream2, item: TokenStream2) -> syn::Result<TokenStream2> {
         let input: ItemImpl = parse2(item)?;
-        let attrs = EntryPointArgs::new(&attr, &input)?;
-        let expanded = EntryPoints::new(&input, attrs).emit();
+        let args = EntryPointArgs::new(&attr)?;
+        let expanded = EntryPointInput::new(&input, args, attr.span()).process();
 
         Ok(quote! {
             #input

sylvia-derive/src/message.rs

@@ -1264,11 +1264,11 @@
     override_entry_points: Vec<OverrideEntryPoint>,
     generics: Vec<&'a GenericParam>,
     where_clause: &'a Option<WhereClause>,
-    attrs: EntryPointArgs,
+    attrs: &'a EntryPointArgs,
 }
 
 impl<'a> EntryPoints<'a> {
-    pub fn new(source: &'a ItemImpl, attrs: EntryPointArgs) -> Self {
+    pub fn new(source: &'a ItemImpl, attrs: &'a EntryPointArgs) -> Self {
         let name = StripGenerics.fold_type(*source.self_ty.clone());
         let parsed_attrs = ParsedSylviaAttributes::new(source.attrs.iter());
         let override_entry_points = parsed_attrs.override_entry_point_attrs;

sylvia-derive/src/parser/entry_point.rs

@@ -3,7 +3,7 @@
 use syn::parse::{Error, Nothing, Parse, ParseStream};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::{parse2, GenericArgument, ItemImpl, Path, Result, Token};
+use syn::{parse2, GenericArgument, Path, Result, Token};
 
 use super::extract_generics_from_path;
 
@@ -15,20 +15,12 @@
 }
 
 impl EntryPointArgs {
-    pub fn new(attr: &TokenStream2, source: &ItemImpl) -> Result<Self> {
+    pub fn new(attr: &TokenStream2) -> Result<Self> {
         let args: Self = parse2(attr.clone()).map_err(|err| {
             emit_error!(attr, err);
             err
         })?;
 
-        if args.generics.len() != source.generics.params.len() {
-            emit_error!(
-                attr.span(),
-                "Missing concrete types.";
-                note = "For every generic type in the contract, a concrete type must be provided in `#[entry_points(generics<T1, T2, ...>)]`.";
-            );
-        }
-
         Ok(args)
     }
 }

sylvia/src/into_response.rs

@@ -11,9 +11,7 @@ impl<C> IntoMsg<C> for SubMsg<Empty> {
         let msg = match self.msg {
             CosmosMsg::Wasm(wasm) => CosmosMsg::Wasm(wasm),
             CosmosMsg::Bank(bank) => CosmosMsg::Bank(bank),
-            #[cfg(feature = "staking")]
             CosmosMsg::Staking(staking) => CosmosMsg::Staking(staking),
-            #[cfg(feature = "staking")]
             CosmosMsg::Distribution(distribution) => CosmosMsg::Distribution(distribution),
             CosmosMsg::Custom(_) => Err(StdError::generic_err(
                 "Custom Empty message should not be sent",

sylvia/tests/ui.rs

@@ -1,4 +1,5 @@
 #[test]
+#[ignore]
 fn ui() {
     let t = trybuild::TestCases::new();
     t.compile_fail("tests/ui/**/*.rs");

sylvia/tests/ui/macros/entry_points.rs

@@ -60,4 +60,23 @@ pub mod missing_generics {
     }
 }
 
+pub mod wrong_order {
+    use super::*;
+
+    pub struct Contract;
+
+    #[contract]
+    #[entry_points]
+    impl Contract {
+        pub fn new() -> Self {
+            Self
+        }
+
+        #[sv::msg(instantiate)]
+        fn instantiate(&self, _ctx: InstantiateCtx) -> StdResult<Response> {
+            Ok(Response::new())
+        }
+    }
+}
+
 fn main() {}