typ 0.1.1

Type-level programming in Rust
Documentation 
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

mod assign;
mod binop;
mod block;
mod enum_;
mod fn_;
mod if_;
mod impl_;
mod lit;
mod match_;
mod misc;
mod struct_;
mod unary;

pub use crate::{
    common::*,
    env::{Env, Variable},
    parse::{CaptureAttr, GenericsAttr, SimpleTypeParam},
    utils::Shared,
    var::{
        ParsePathVar, ParsePurePath, ParsePureType, ParsePureWherePredicate,
        ParseTypeParamBoundsVar, ParseTypeVar, ParseWherePredicateVar, PathArgumentsVar, PathVar,
        PredicateTypeVar, QSelfVar, SegmentVar, Subsitution, TraitBoundModifierVar, TraitBoundVar,
        TypeParamBoundVar, TypePathVar, TypeTupleVar, TypeVar, WherePredicateVar,
    },
};
pub use assign::*;
pub use binop::*;
pub use block::*;
pub use enum_::*;
pub use fn_::*;
pub use if_::*;
pub use impl_::*;
pub use lit::*;
pub use match_::*;
pub use misc::*;
pub use struct_::*;
pub use unary::*;

pub fn translate_items(items: &[Item]) -> syn::Result<TokenStream> {
    let tokens_vec: Vec<_> = items
        .into_iter()
        .map(|item| {
            let tokens = match item {
                Item::Enum(enum_) => translate_enum(&enum_)?,
                Item::Fn(fn_) => {
                    let ItemFn {
                        sig, block, vis, ..
                    } = fn_;
                    translate_fn(vis, sig, block, None, None)?
                }
                Item::Struct(struct_) => translate_struct(&struct_)?,
                Item::Impl(impl_) => translate_impl(&impl_)?,
                Item::Use(use_) => translate_use(&use_),
                _ => {
                    return Err(Error::new(item.span(), "unsupported item kind"));
                }
            };
            Ok(tokens)
        })
        .try_collect()?;

    let expanded = quote! {
        #(#tokens_vec)*
    };

    Ok(expanded)
}

fn translate_use(use_: &ItemUse) -> TokenStream {
    // return as it is
    quote! { #use_ }
}