diff --git a/.vscode/extensions.json b/.vscode/extensions.json index 06e99e1d1..13a358fb6 100644 --- a/.vscode/extensions.json +++ b/.vscode/extensions.json @@ -1,3 +1,8 @@ { - "recommendations": ["matklad.rust-analyzer", "dbaeumer.vscode-eslint", "octref.vetur", "formulahendry.auto-close-tag"] + "recommendations": [ + "matklad.rust-analyzer", + "dbaeumer.vscode-eslint", + "octref.vetur", + "formulahendry.auto-close-tag" + ] } \ No newline at end of file diff --git a/client/web/package.json b/client/web/package.json index 3dc8e2a4d..4e178d417 100644 --- a/client/web/package.json +++ b/client/web/package.json @@ -54,4 +54,4 @@ "git add" ] } -} +} \ No newline at end of file diff --git a/core/editor/src/misc/macros.rs b/core/editor/src/misc/macros.rs index 34e2dd8b5..ef20f5521 100644 --- a/core/editor/src/misc/macros.rs +++ b/core/editor/src/misc/macros.rs @@ -76,7 +76,7 @@ macro_rules! gen_tools_hash_map { /// }; /// ``` macro_rules! match_variant_name { - (match ($e:expr) { $($v:ident),* $(,)? }) => { + (match ($e:expr) { $($v:ident),* $(,)? }) => { match $e { $( $v { .. } => stringify!($v) diff --git a/core/proc-macro/src/lib.rs b/core/proc-macro/src/lib.rs index e8068aee8..12802615d 100644 --- a/core/proc-macro/src/lib.rs +++ b/core/proc-macro/src/lib.rs @@ -24,7 +24,7 @@ use syn::parse_macro_input; /// /// # Helper attributes /// - `#[sub_discriminant]`: only usable on variants with a single field; instead of no fields, the discriminant of the single field will be included in the discriminant, -/// acting as a sub-discriminant. +/// acting as a sub-discriminant. /// - `#[discriminant_attr(…)]`: usable on the enum itself or on any variant; applies `#[…]` in its place on the discriminant. /// /// # Attributes on the Discriminant @@ -40,20 +40,20 @@ use syn::parse_macro_input; /// #[derive(ToDiscriminant)] /// #[discriminant_attr(derive(Debug, Eq, PartialEq))] /// pub enum EnumA { -/// A(u8), -/// #[sub_discriminant] -/// B(EnumB) +/// A(u8), +/// #[sub_discriminant] +/// B(EnumB) /// } /// /// #[derive(ToDiscriminant)] /// #[discriminant_attr(derive(Debug, Eq, PartialEq))] /// #[discriminant_attr(repr(u8))] /// pub enum EnumB { -/// Foo(u8), -/// Bar(String), -/// #[cfg(feature = "some-feature")] -/// #[discriminant_attr(cfg(feature = "some-feature"))] -/// WindowsBar(OsString) +/// Foo(u8), +/// Bar(String), +/// #[cfg(feature = "some-feature")] +/// #[discriminant_attr(cfg(feature = "some-feature"))] +/// WindowsBar(OsString) /// } /// /// let a = EnumA::A(1); @@ -73,7 +73,7 @@ pub fn derive_discriminant(input_item: TokenStream) -> TokenStream { /// /// # Helper Attributes /// - `#[parent(, )]` (**required**): declare the parent type (``) -/// and a function (``, has to evaluate to a single arg function) for converting a value of this type to the parent type +/// and a function (``, has to evaluate to a single arg function) for converting a value of this type to the parent type /// - `#[parent_is_top]`: Denote that the parent type has no further parent type (this is required because otherwise the `From` impls for parent and top parent would overlap) /// /// # Example @@ -85,23 +85,23 @@ pub fn derive_discriminant(input_item: TokenStream) -> TokenStream { /// struct A { u: u8, b: B }; /// /// impl A { -/// pub fn from_b(b: B) -> Self { -/// Self { u: 7, b } -/// } +/// pub fn from_b(b: B) -> Self { +/// Self { u: 7, b } +/// } /// } /// /// impl TransitiveChild for A { -/// type Parent = Self; -/// type TopParent = Self; +/// type Parent = Self; +/// type TopParent = Self; /// } /// /// #[derive(TransitiveChild, Debug, Eq, PartialEq)] /// #[parent(A, A::from_b)] /// #[parent_is_top] /// enum B { -/// Foo, -/// Bar, -/// Child(C) +/// Foo, +/// Bar, +/// Child(C) /// } /// /// #[derive(TransitiveChild, Debug, Eq, PartialEq)] @@ -134,41 +134,41 @@ pub fn derive_transitive_child(input_item: TokenStream) -> TokenStream { /// /// #[derive(AsMessage)] /// pub enum TopMessage { -/// A(u8), -/// B(u16), -/// #[child] -/// C(MessageC), -/// #[child] -/// D(MessageD) +/// A(u8), +/// B(u16), +/// #[child] +/// C(MessageC), +/// #[child] +/// D(MessageD) /// } /// /// impl TransitiveChild for TopMessage { -/// type Parent = Self; -/// type TopParent = Self; +/// type Parent = Self; +/// type TopParent = Self; /// } /// /// #[derive(TransitiveChild, AsMessage, Copy, Clone)] /// #[parent(TopMessage, TopMessage::C)] /// #[parent_is_top] /// pub enum MessageC { -/// X1, -/// X2 +/// X1, +/// X2 /// } /// /// #[derive(TransitiveChild, AsMessage, Copy, Clone)] /// #[parent(TopMessage, TopMessage::D)] /// #[parent_is_top] /// pub enum MessageD { -/// Y1, -/// #[child] -/// Y2(MessageE) +/// Y1, +/// #[child] +/// Y2(MessageE) /// } /// /// #[derive(TransitiveChild, AsMessage, Copy, Clone)] /// #[parent(MessageD, MessageD::Y2)] /// pub enum MessageE { -/// Alpha, -/// Beta +/// Alpha, +/// Beta /// } /// /// let c = MessageC::X1; @@ -195,18 +195,18 @@ pub fn derive_message(input_item: TokenStream) -> TokenStream { /// # Usage /// There are three possible argument syntaxes you can use: /// 1. no arguments: this is for the top-level message enum. It derives `ToDiscriminant`, `AsMessage` on the discriminant, and implements `TransitiveChild` on both -/// (the parent and top parent being the respective types themselves). -/// It also derives the following `std` traits on the discriminant: `Debug, Copy, Clone, PartialEq, Eq, Hash`. +/// (the parent and top parent being the respective types themselves). +/// It also derives the following `std` traits on the discriminant: `Debug, Copy, Clone, PartialEq, Eq, Hash`. /// 2. two arguments: this is for message enums whose direct parent is the top level message enum. The syntax is `#[impl_message(, )]`, -/// where `` is the parent message type and `` is the identifier of the variant used to construct this child. -/// It derives `ToDiscriminant`, `AsMessage` on the discriminant, and `TransitiveChild` on both (adding `#[parent_is_top]` to both). -/// It also derives the following `std` traits on the discriminant: `Debug, Copy, Clone, PartialEq, Eq, Hash`. +/// where `` is the parent message type and `` is the identifier of the variant used to construct this child. +/// It derives `ToDiscriminant`, `AsMessage` on the discriminant, and `TransitiveChild` on both (adding `#[parent_is_top]` to both). +/// It also derives the following `std` traits on the discriminant: `Debug, Copy, Clone, PartialEq, Eq, Hash`. /// 3. three arguments: this is for all other message enums that are transitive children of the top level message enum. The syntax is -/// `#[impl_message(, , )]`, where the first `` is the top parent message type, the secont `` is the parent message type -/// and `` is the identifier of the variant used to construct this child. -/// It derives `ToDiscriminant`, `AsMessage` on the discriminant, and `TransitiveChild` on both. -/// It also derives the following `std` traits on the discriminant: `Debug, Copy, Clone, PartialEq, Eq, Hash`. -/// **This third option will likely change in the future** +/// `#[impl_message(, , )]`, where the first `` is the top parent message type, the secont `` is the parent message type +/// and `` is the identifier of the variant used to construct this child. +/// It derives `ToDiscriminant`, `AsMessage` on the discriminant, and `TransitiveChild` on both. +/// It also derives the following `std` traits on the discriminant: `Debug, Copy, Clone, PartialEq, Eq, Hash`. +/// **This third option will likely change in the future** #[proc_macro_attribute] pub fn impl_message(attr: TokenStream, input_item: TokenStream) -> TokenStream { TokenStream::from(combined_message_attrs_impl(attr.into(), input_item.into()).unwrap_or_else(|err| err.to_compile_error())) @@ -221,12 +221,12 @@ pub fn impl_message(attr: TokenStream, input_item: TokenStream) -> TokenStream { /// /// #[derive(Hint)] /// pub enum StateMachine { -/// #[hint(rmb = "foo", lmb = "bar")] -/// Ready, -/// #[hint(alt = "baz")] -/// RMBDown, -/// // no hint (also ok) -/// LMBDown +/// #[hint(rmb = "foo", lmb = "bar")] +/// Ready, +/// #[hint(alt = "baz")] +/// RMBDown, +/// // no hint (also ok) +/// LMBDown /// } /// ``` #[proc_macro_derive(Hint, attributes(hint))] @@ -239,30 +239,30 @@ pub fn derive_hint(input_item: TokenStream) -> TokenStream { /// # Example /// ```ignore /// match (example_tool_state, event) { -/// (ToolState::Ready, Event::MouseDown(mouse_state)) if *mouse_state == MouseState::Left => { -/// #[edge("LMB Down")] -/// ToolState::Pending -/// } -/// (SelectToolState::Pending, Event::MouseUp(mouse_state)) if *mouse_state == MouseState::Left => { -/// #[edge("LMB Up: Select Object")] -/// SelectToolState::Ready -/// } -/// (SelectToolState::Pending, Event::MouseMove(x,y)) => { -/// #[edge("Mouse Move")] -/// SelectToolState::TransformSelected -/// } -/// (SelectToolState::TransformSelected, Event::MouseMove(x,y)) => { -/// #[egde("Mouse Move")] -/// SelectToolState::TransformSelected -/// } -/// (SelectToolState::TransformSelected, Event::MouseUp(mouse_state)) if *mouse_state == MouseState::Left => { -/// #[edge("LMB Up")] -/// SelectToolState::Ready -/// } -/// (state, _) => { -/// // Do nothing -/// state -/// } +/// (ToolState::Ready, Event::MouseDown(mouse_state)) if *mouse_state == MouseState::Left => { +/// #[edge("LMB Down")] +/// ToolState::Pending +/// } +/// (SelectToolState::Pending, Event::MouseUp(mouse_state)) if *mouse_state == MouseState::Left => { +/// #[edge("LMB Up: Select Object")] +/// SelectToolState::Ready +/// } +/// (SelectToolState::Pending, Event::MouseMove(x,y)) => { +/// #[edge("Mouse Move")] +/// SelectToolState::TransformSelected +/// } +/// (SelectToolState::TransformSelected, Event::MouseMove(x,y)) => { +/// #[egde("Mouse Move")] +/// SelectToolState::TransformSelected +/// } +/// (SelectToolState::TransformSelected, Event::MouseUp(mouse_state)) if *mouse_state == MouseState::Left => { +/// #[edge("LMB Up")] +/// SelectToolState::Ready +/// } +/// (state, _) => { +/// // Do nothing +/// state +/// } /// } /// ``` #[proc_macro_attribute]