Implemented constructor argument capture shorthands

Closes #2

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 * The bump format shorthand now does not imply `'a: 'bump` anymore, where `'a` is the component's lifetime.
 
+* You can now prefix constructor arguments with an explicit visibility (`priv`, `pub`, `pub(restriction)`) to cature them as component instance fields.
+
 ## 0.0.2
 
 2020-10-08

README.md

@@ -120,12 +120,17 @@ use std::cell::RefCell;
 fn schedule_render() { /* ... */ }
 
 component! {
-  pub Counter(initial: i32, step: i32)()
+  pub Counter(
+    initial: i32,
+    priv step: i32,
+    /// This component's class attribute value.
+    pub class: &'static str, // ⁵
+  )()
 
   |value = RefCell::<i32>::new(initial)|; // shorthand capture
-  |step: i32 = {step}|; // long form capture, ²
 
   <div
+    ."class" = {self.class} // ⁶
     "The current value is: " !{*self.value.borrow()} <br>
 
     <button
@@ -149,7 +154,8 @@ impl Counter {
 }
 ```
 
-² <https://github.com/Tamschi/Asteracea/issues/2>
+⁵ <https://github.com/Tamschi/Asteracea/issues/5>
+⁶ <https://github.com/Tamschi/Asteracea/issues/6>
 
 ## License
 

proc-macro-definitions/Cargo.toml

@@ -32,6 +32,7 @@ styles = ["rand"]
 
 [dependencies]
 call2-for-syn = "1.0.0"
+debugless-unwrap = "0.0.3"
 heck = "0.3.1"
 lazy_static = "1.4.0"
 quote = "1.0.2"

proc-macro-definitions/src/component_declaration/constructor_argument.rs

@@ -0,0 +1,48 @@
+use quote::quote;
+use syn::{
+	parse::Parse, parse::ParseStream, Attribute, Error, FnArg, PatType, Result, Token, Visibility,
+};
+
+pub struct ConstructorArgument {
+	pub capture: Capture,
+	pub fn_arg: PatType,
+}
+
+pub enum Capture {
+	No,
+	Yes(syn::Visibility),
+}
+
+impl Parse for ConstructorArgument {
+	fn parse(input: ParseStream) -> Result<Self> {
+		let attrs = input.call(Attribute::parse_outer)?;
+		let capture = if input.peek(Token![priv]) {
+			input.parse::<Token![priv]>().unwrap();
+			Capture::Yes(Visibility::Inherited)
+		} else {
+			match input.parse()? {
+				Visibility::Inherited => Capture::No,
+				visibility => Capture::Yes(visibility),
+			}
+		};
+		Ok(Self {
+			fn_arg: match input.parse::<FnArg>()? {
+				FnArg::Receiver(r) => {
+					return Err(Error::new_spanned(
+						r,
+						"Component constructors cannot expect `self` parameters.",
+					));
+				}
+				FnArg::Typed(pat_type)
+					if matches!(capture, Capture::No) || pat_type.attrs.is_empty() =>
+				{
+					PatType { attrs, ..pat_type }
+				}
+				FnArg::Typed(PatType { attrs, .. }) => {
+					return Err(Error::new_spanned(quote!(#(#attrs)*), "Attributes are currently not available in this position. Place them before the visibility modifier instead."));
+				}
+			},
+			capture,
+		})
+	}
+}

proc-macro-definitions/src/component_declaration.rs → proc-macro-definitions/src/component_declaration/mod.rs

@@ -1,10 +1,12 @@
+use self::constructor_argument::ConstructorArgument;
 use crate::{
 	asteracea_ident,
 	parse_with_context::{ParseContext, ParseWithContext},
 	part::{CaptureDefinition, GenerateContext},
 	warn, Configuration, MapMessage, Part, YankAny,
 };
 use call2_for_syn::call2;
+use debugless_unwrap::DebuglessUnwrapNone as _;
 use heck::KebabCase;
 use proc_macro2::{Span, TokenStream};
 use quote::{quote, quote_spanned, ToTokens};
@@ -15,11 +17,13 @@ use syn::{
 	punctuated::Punctuated,
 	spanned::Spanned,
 	token::Paren,
-	Attribute, Error, FnArg, Generics, Ident, Lifetime, LitStr, ReturnType, Token, Type,
+	Attribute, Error, FnArg, Generics, Ident, Lifetime, LitStr, PatType, ReturnType, Token, Type,
 	Visibility, WherePredicate,
 };
 use unzip_n::unzip_n;
 
+mod constructor_argument;
+
 unzip_n!(5);
 unzip_n!(6);
 unzip_n!(7);
@@ -32,7 +36,7 @@ pub struct ComponentDeclaration {
 	component_wheres: Vec<WherePredicate>,
 	constructor_attributes: Vec<Attribute>,
 	constructor_generics: Option<Generics>,
-	constructor_args: Vec<FnArg>,
+	constructor_args: Vec<ConstructorArgument>,
 	render_attributes: Vec<Attribute>,
 	render_generics: Option<Generics>,
 	render_paren: Paren,
@@ -172,7 +176,7 @@ impl Parse for ComponentDeclaration {
 		let constructor_args;
 		parenthesized!(constructor_args in input);
 		let constructor_args = Punctuated::<_, Token![,]>::parse_terminated(&constructor_args)?;
-		let constructor_args = constructor_args.into_iter().collect();
+		let constructor_args: Vec<ConstructorArgument> = constructor_args.into_iter().collect();
 
 		let render_attributes = input.call(Attribute::parse_outer)?;
 
@@ -384,6 +388,35 @@ impl Parse for ComponentDeclaration {
 			}
 		};
 
+		// These captures are put at the very end of the constructor since they always move their value.
+		for constructor_argument in constructor_args.iter() {
+			if let ConstructorArgument {
+				capture: constructor_argument::Capture::Yes(visibility),
+				fn_arg,
+			} = constructor_argument
+			{
+				let span = match visibility {
+					Visibility::Inherited => fn_arg.span(),
+					visibility => visibility.span(),
+				};
+				let attrs = &fn_arg.attrs;
+				let pat = &fn_arg.pat;
+				let arg = {
+					let PatType {
+						colon_token, ty, ..
+					} = fn_arg;
+					quote!(#pat#colon_token #ty)
+				};
+				call2(
+					quote_spanned!(span=> |#(#attrs)* #visibility #arg = {#pat}|;),
+					|input| {
+						Part::<ComponentRenderConfiguration>::parse_with_context(input, &mut cx)
+					},
+				)?
+				.debugless_unwrap_none()
+			}
+		}
+
 		if !input.is_empty() {
 			return Err(input.error(
 				"Currently, only one root element is supported.
@@ -748,6 +781,12 @@ impl ComponentDeclaration {
 
 		let body = body.part_tokens(&GenerateContext::default())?;
 
+		let constructor_args = constructor_args.into_iter().map(|arg| {
+			let mut fn_arg = arg.fn_arg;
+			fn_arg.attrs.clear();
+			fn_arg
+		});
+
 		Ok(quote! {
 			#new_statics
 			#render_statics