mirrors/Graphite
1
0
Fork 0
mirror of https://github.com/GraphiteEditor/Graphite.git synced 2025-08-04 13:30:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Upgrade to the Rust 2024 edition (#2367)

Browse source 
* Update to rust 2024 edition

* Fixes

* Clean up imports

* Cargo fmt again

---------

Co-authored-by: Keavon Chambers <keavon@keavon.com>
This commit is contained in:
Dennis Kobert 2025-03-13 01:29:12 +01:00 • committed by GitHub
parent 927d7dd9b2
commit beb1c6ae64
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
253 changed files with 980 additions and 1371 deletions
Download patch file Download diff file Expand all files Collapse all files

4
node-graph/node-macro/Cargo.toml
View file

@ -2,9 +2,9 @@
name = "node-macro"
publish = false
version = "0.0.0"
rust-version = "1.79"
rust-version = "1.85"
authors = ["Graphite Authors <contact@graphite.rs>"]
edition = "2021"
edition = "2024"
readme = "../../README.md"
homepage = "https://graphite.rs"
repository = "https://github.com/GraphiteEditor/Graphite"

20
node-graph/node-macro/src/codegen.rs
View file

@ -1,14 +1,13 @@
use std::sync::atomic::AtomicU64;
use crate::parsing::*;
use convert_case::{Case, Casing};
use proc_macro2::TokenStream as TokenStream2;
use proc_macro_crate::FoundCrate;
use proc_macro2::TokenStream as TokenStream2;
use quote::{format_ident, quote};
use std::sync::atomic::AtomicU64;
use syn::punctuated::Punctuated;
use syn::spanned::Spanned;
use syn::token::Comma;
use syn::{parse_quote, Error, Ident, PatIdent, Token, WhereClause, WherePredicate};
use syn::{Error, Ident, PatIdent, Token, WhereClause, WherePredicate, parse_quote};
static NODE_ID: AtomicU64 = AtomicU64::new(0);
pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStream2> {
@ -68,8 +67,8 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
})
.collect();
let struct_fields = field_names.iter().zip(struct_generics.iter()).map(|(name, gen)| {
quote! { pub(super) #name: #gen }
let struct_fields = field_names.iter().zip(struct_generics.iter()).map(|(name, r#gen)| {
quote! { pub(super) #name: #r#gen }
});
let graphene_core = match graphene_core_crate {
@ -225,8 +224,8 @@ pub(crate) fn generate_node_code(parsed: &ParsedNodeFn) -> syn::Result<TokenStre
);
struct_where_clause.predicates.extend(extra_where);
let new_args = struct_generics.iter().zip(field_names.iter()).map(|(gen, name)| {
quote! { #name: #gen }
let new_args = struct_generics.iter().zip(field_names.iter()).map(|(r#gen, name)| {
quote! { #name: #r#gen }
});
let async_keyword = is_async.then(|| quote!(async));
@ -520,7 +519,7 @@ fn generate_register_node_impl(parsed: &ParsedNodeFn, field_names: &[&Ident], st
);
}
#[cfg(target_arch = "wasm32")]
#[no_mangle]
#[unsafe(no_mangle)]
extern "C" fn #registry_name() {
register_node();
register_metadata();
@ -528,7 +527,8 @@ fn generate_register_node_impl(parsed: &ParsedNodeFn, field_names: &[&Ident], st
})
}
use syn::{visit_mut::VisitMut, GenericArgument, Lifetime, Type};
use syn::visit_mut::VisitMut;
use syn::{GenericArgument, Lifetime, Type};
struct LifetimeReplacer(&'static str);

8
node-graph/node-macro/src/lib.rs
View file

@ -1,12 +1,12 @@
// TODO: Deprecate and remove this file
use proc_macro::TokenStream;
use proc_macro2::Span;
use proc_macro_error2::proc_macro_error;
use quote::{format_ident, quote, ToTokens};
use proc_macro2::Span;
use quote::{ToTokens, format_ident, quote};
use syn::{
parse_macro_input, punctuated::Punctuated, token::Comma, AngleBracketedGenericArguments, AssocType, FnArg, GenericArgument, GenericParam, Ident, ItemFn, Lifetime, Pat, PatIdent, PathArguments,
PathSegment, PredicateType, ReturnType, Token, TraitBound, Type, TypeImplTrait, TypeParam, TypeParamBound, TypeTuple, WhereClause, WherePredicate,
AngleBracketedGenericArguments, AssocType, FnArg, GenericArgument, GenericParam, Ident, ItemFn, Lifetime, Pat, PatIdent, PathArguments, PathSegment, PredicateType, ReturnType, Token, TraitBound,
Type, TypeImplTrait, TypeParam, TypeParamBound, TypeTuple, WhereClause, WherePredicate, parse_macro_input, punctuated::Punctuated, token::Comma,
};
mod codegen;

12
node-graph/node-macro/src/parsing.rs
View file

@ -1,13 +1,13 @@
use convert_case::{Case, Casing};
use indoc::{formatdoc, indoc};
use proc_macro2::TokenStream as TokenStream2;
use quote::{format_ident, ToTokens};
use quote::{ToTokens, format_ident};
use syn::parse::{Parse, ParseStream, Parser};
use syn::punctuated::Punctuated;
use syn::spanned::Spanned;
use syn::token::{Comma, RArrow};
use syn::{
parse_quote, AttrStyle, Attribute, Error, Expr, ExprTuple, FnArg, GenericParam, Ident, ItemFn, Lit, LitFloat, LitStr, Meta, Pat, PatIdent, PatType, Path, ReturnType, Type, TypeParam, WhereClause,
AttrStyle, Attribute, Error, Expr, ExprTuple, FnArg, GenericParam, Ident, ItemFn, Lit, LitFloat, LitStr, Meta, Pat, PatIdent, PatType, Path, ReturnType, Type, TypeParam, WhereClause, parse_quote,
};
use crate::codegen::generate_node_code;
@ -519,11 +519,7 @@ fn parse_node_type(ty: &Type) -> (bool, Option<Type>, Option<Type>) {
let input_type = args.args.iter().find_map(|arg| if let syn::GenericArgument::Type(ty) = arg { Some(ty.clone()) } else { None });
let output_type = args.args.iter().find_map(|arg| {
if let syn::GenericArgument::AssocType(assoc_type) = arg {
if assoc_type.ident == "Output" {
Some(assoc_type.ty.clone())
} else {
None
}
if assoc_type.ident == "Output" { Some(assoc_type.ty.clone()) } else { None }
} else {
None
}
@ -597,8 +593,8 @@ impl ParsedNodeFn {
#[cfg(test)]
mod tests {
use super::*;
use proc_macro2::Span;
use proc_macro_crate::FoundCrate;
use proc_macro2::Span;
use quote::{quote, quote_spanned};
use syn::parse_quote;
fn pat_ident(name: &str) -> PatIdent {

4
node-graph/node-macro/src/validation.rs
View file

@ -1,8 +1,8 @@
use crate::parsing::{Implementation, ParsedField, ParsedNodeFn};
use proc_macro_error2::emit_error;
use quote::quote;
use syn::{spanned::Spanned, GenericParam, Type};
use syn::spanned::Spanned;
use syn::{GenericParam, Type};
pub fn validate_node_fn(parsed: &ParsedNodeFn) -> syn::Result<()> {
let validators: &[fn(&ParsedNodeFn)] = &[