primwrap 1.1.1

Derive operation traits for primitive wrapper structs.
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
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

// SPDX-License-Identifier: Apache-2.0

mod gen;
mod ops;

use proc_macro::TokenStream;
use std::collections::HashSet;
use strum::EnumString;
use virtue::parse::{Attribute, AttributeLocation, StructBody};
use virtue::prelude::*;
use virtue::utils::{parse_tagged_attribute, ParsedAttribute};
use ops::*;

#[derive(EnumString, Eq, PartialEq, Hash)]
#[strum(ascii_case_insensitive)]
enum Group {
	Arithmetic,
	Bitwise,
	Formatting,
	Comparison,
	Accumulation
}

/// Derives arithmetic, bitwise, comparison, and formatting traits on a primitive
/// wrapper struct, exposing its inner type. Integer, float, and boolean types are
/// supported.
///
/// The implemented traits can be selected with a `#[primwrap(...)]` attribute:
/// - `arithmetic` enables `Add`, `Sub`, `Mul`, `Div`, `Rem`, and `Neg`
/// - `bitwise` enables `Not`, `BitAnd`, `BitOr`, `BitXor`, `Shl`, and `Shr`
/// - `formatting` enables `Debug`, `Display`, `Binary`, `Octal`, `LowerExp`,
///   `LowerHex`, `UpperExp`, and `UpperHex`
/// - `comparison` enables `PartialEq`/`PartialOrd` with the inner type
/// - `accumulation` enables `Sum` and `Product`
#[proc_macro_derive(Primitive, attributes(primwrap))]
pub fn primitive_derive(input: TokenStream) -> TokenStream {
	let expand = || {
		let (
			gen,
			attributes,
			Body::Struct(
				StructBody {
					fields: Some(Fields::Tuple(fields))
				}
			)
		) = Parse::new(input)?.into_generator() else {
			return Err(Error::custom("expected tuple struct"))
		};
		let groups = parse_attributes(attributes)?;
		let [field] = &fields[..] else {
			return Err(Error::custom("expected tuple struct with one field"))
		};
		let [TokenTree::Ident(inner_type)] = &field.r#type[..] else {
			return Err(Error::custom("unknown type"))
		};
		let ref target = gen.target_name().to_string();
		let ref inner = inner_type.to_string();
		let mut impl_sink = gen.into();

		for group in &groups {
			match group {
				Group::Arithmetic => Arithmetic::generate_all(&mut impl_sink, target, inner),
				Group::Bitwise    => Bit       ::generate_all(&mut impl_sink, target, inner),
				Group::Formatting => Formatting::generate_all(&mut impl_sink, target, inner),
				Group::Comparison => Comparison::generate_all(&mut impl_sink, target, inner),
				Group::Accumulation
					if groups.contains(&Group::Arithmetic) =>
					Accumulation::generate_all(&mut impl_sink, target, inner),
				_ => { }
			}
		}

		impl_sink.finish()
	};

	expand().unwrap_or_else(Error::into_token_stream)
}

fn parse_attributes(attributes: Vec<Attribute>) -> Result<HashSet<Group>> {
	let attrs = attributes.iter().filter_map(|Attribute { location, tokens, .. }|
		matches!(location, AttributeLocation::Container).then_some(tokens)
	).collect::<Vec<_>>();

	if attrs.is_empty() {
		return Ok([
			Group::Arithmetic,
			Group::Bitwise,
			Group::Formatting,
			Group::Comparison,
			Group::Accumulation,
		].into())
	}

	let mut groups = HashSet::with_capacity(5);
	for tokens in attrs {
		let Some(parsed) = parse_tagged_attribute(tokens, "primwrap")? else { continue };
		for group in parsed {
			match group {
				ParsedAttribute::Tag(group) => {
					groups.insert(
						group.to_string()
							 .parse()
							 .map_err(|_|
								 Error::custom_at(
									 r#"expected "arithmetic", "bitwise", "formatting", or "comparison""#,
									 group.span()
								 )
							 )?
					);
				}
				ParsedAttribute::Property(_, val) =>
					return Err(Error::custom_at("expected identifier", val.span())),
				_ => return Err(Error::custom("expected identifier"))
			}
		}
	}
	Ok(groups)
}