1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
//! This crate defines a custom derive macro `Iterator`. Should not be used //! directly, but only through `enso-shapely` crate, as it provides utilities //! necessary for the generated code to compile. #![feature(bool_to_option)] #![feature(exact_size_is_empty)] #![warn(missing_docs)] #![warn(trivial_casts)] #![warn(trivial_numeric_casts)] #![warn(unused_import_braces)] #![warn(unused_qualifications)] #![warn(unsafe_code)] #![warn(missing_copy_implementations)] #![warn(missing_debug_implementations)] extern crate proc_macro; mod derive_clone_ref; mod derive_iterator; mod overlappable; mod prelude { pub use enso_macro_utils::repr; pub use proc_macro2::Span; pub use proc_macro2::TokenStream; pub use quote::quote; } use crate::derive_iterator::IsMut; /// For `struct Foo<T>` or `enum Foo<T>` provides: /// * `IntoIterator` implementations for `&'t Foo<T>`, `iter` and `into_iter` /// methods. /// /// The iterators will: /// * for structs: go over each field that declared type is same as the /// struct's last type parameter. /// * enums: delegate to current constructor's nested value's iterator. /// /// Enums are required to use only a single element tuple-like variant. This /// limitation should be lifted in the future. /// /// Any dependent type stored in struct, tuple or wrapped in enum should have /// dependency only in its last type parameter. All dependent types that are not /// tuples nor directly the yielded type, are required to provide `iter` method /// that returns a compatible iterator (possible also derived). /// /// Caller must have the following features enabled: /// ``` /// #![feature(generators)] /// #![feature(min_type_alias_impl_trait)] /// ``` /// /// When used on type that takes no type parameters, like `struct Foo`, does /// nothing but yields no errors. #[proc_macro_derive(Iterator)] pub fn derive_iterator (input: proc_macro::TokenStream) -> proc_macro::TokenStream { derive_iterator::derive(input,IsMut::Immutable) } /// Same as `derive(Iterator)` but generates mutable iterator. /// /// It is separate, as some types allow deriving immutable iterator but ont the /// mutable one. #[proc_macro_derive(IteratorMut)] pub fn derive_iterator_mut (input: proc_macro::TokenStream) -> proc_macro::TokenStream { derive_iterator::derive(input,IsMut::Mutable) } /// Derives `CloneRef` implementation for given type. It performs `clone_ref` on every member /// field. The input type must implement `Clone` and its every field must implement `CloneRef`. /// /// For generic types no bounds are introduced in the generated implementation. To customize this /// behavior user might add `#[clone_ref(bound="…")]` attribute. Then the generated implementation /// will use the provided bounds. /// /// Moreover, for a given struct `X` this macro generates also `impl From<&X> for X` which uses /// `CloneRef` under the hood. The semantics of `CloneRef` makes each object to naturally provide /// transformation from reference to an owned type. /// /// Supported inputs are structs (unit, named, unnamed), enums (with unit, named, unnamed and no /// variants at all). Unions are currently not supported. #[proc_macro_derive(CloneRef, attributes(clone_ref))] pub fn derive_clone_ref (input: proc_macro::TokenStream) -> proc_macro::TokenStream { derive_clone_ref::derive(input) } #[allow(missing_docs)] #[proc_macro_attribute] pub fn overlappable ( attrs : proc_macro::TokenStream , input : proc_macro::TokenStream ) -> proc_macro::TokenStream { overlappable::overlappable(attrs,input) }