From 8a6717c61be2739b0830d603a7e18cdaccd3aa57 Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Tue, 28 Apr 2026 00:58:34 -0700 Subject: [PATCH 1/2] can `cargo clippy --allow-dirty --fix -- -Wclippy::use_self` --- cargo-pgrx/src/cargo.rs | 12 +- cargo-pgrx/src/command/bench.rs | 5 +- cargo-pgrx/src/command/regress.rs | 18 +-- cargo-pgrx/src/command/run.rs | 7 +- cargo-pgrx/src/command/schema.rs | 2 +- cargo-pgrx/src/command/sudo_install.rs | 2 +- cargo-pgrx/src/command/test.rs | 5 +- cargo-pgrx/src/command/version.rs | 5 +- cargo-pgrx/src/manifest.rs | 8 +- cargo-pgrx/src/object_utils.rs | 4 +- pgrx-bindgen/src/build.rs | 4 +- pgrx-macros/src/rewriter.rs | 2 +- pgrx-pg-config/src/lib.rs | 38 ++--- .../src/aggregate/options.rs | 12 +- pgrx-sql-entity-graph/src/composite_type.rs | 2 +- pgrx-sql-entity-graph/src/control_file.rs | 4 +- .../src/extension_sql/entity.rs | 22 +-- .../src/extension_sql/mod.rs | 32 ++-- pgrx-sql-entity-graph/src/extern_args.rs | 144 +++++++++--------- pgrx-sql-entity-graph/src/fmt.rs | 2 +- .../src/metadata/sql_translatable.rs | 26 ++-- .../src/pg_extern/argument.rs | 2 +- .../src/pg_extern/attribute.rs | 42 ++--- pgrx-sql-entity-graph/src/pg_extern/cast.rs | 12 +- pgrx-sql-entity-graph/src/pg_extern/mod.rs | 4 +- .../src/pg_extern/operator.rs | 4 +- .../src/pg_extern/returning.rs | 44 +++--- pgrx-sql-entity-graph/src/pg_trigger/mod.rs | 2 +- pgrx-sql-entity-graph/src/positioning_ref.rs | 14 +- .../src/postgres_type/entity.rs | 4 +- 30 files changed, 238 insertions(+), 246 deletions(-) diff --git a/cargo-pgrx/src/cargo.rs b/cargo-pgrx/src/cargo.rs index 2bf17fcf6e..d4fc28a970 100644 --- a/cargo-pgrx/src/cargo.rs +++ b/cargo-pgrx/src/cargo.rs @@ -97,13 +97,13 @@ impl Cargo { } // subcommand *must* go first among subcommand-relative args - if self.subcmd != "" { + if !self.subcmd.is_empty() { cmd.arg(&self.subcmd); } else { panic!("`Cargo::into_command` requires a subcommand to be set, was: {self:?}") } - let Cargo { + let Self { features, stdio, manifest, @@ -186,9 +186,9 @@ pub enum Stdio { impl Stdio { fn into_stdio(self) -> Option { match self { - Stdio::Inherit => Some(process::Stdio::inherit()), - Stdio::Null => Some(process::Stdio::null()), - Stdio::Default => None, + Self::Inherit => Some(process::Stdio::inherit()), + Self::Null => Some(process::Stdio::null()), + Self::Default => None, } } } @@ -288,7 +288,7 @@ pub enum CargoProfile { } impl CargoProfile { - pub fn from_flags(profile: Option<&str>, default: CargoProfile) -> eyre::Result { + pub fn from_flags(profile: Option<&str>, default: Self) -> eyre::Result { match profile { // Cargo treats `--profile release` the same as `--release`. Some("release") => Ok(Self::Release), diff --git a/cargo-pgrx/src/command/bench.rs b/cargo-pgrx/src/command/bench.rs index f8e2fb8f7f..d2df40a756 100644 --- a/cargo-pgrx/src/command/bench.rs +++ b/cargo-pgrx/src/command/bench.rs @@ -261,11 +261,10 @@ impl CommandExecute for Bench { baseline.as_ref(), compare_group.as_ref().map(|group| group.group_name.as_str()), )); - if show_human_output { - if let Some(completed_benchmark) = summary_benchmarks.last() { + if show_human_output + && let Some(completed_benchmark) = summary_benchmarks.last() { print_completed_benchmark(completed_benchmark); } - } } let status = if failures == 0 { diff --git a/cargo-pgrx/src/command/regress.rs b/cargo-pgrx/src/command/regress.rs index 369ca03cd0..6e8ed72ad2 100644 --- a/cargo-pgrx/src/command/regress.rs +++ b/cargo-pgrx/src/command/regress.rs @@ -437,7 +437,7 @@ impl CommandExecute for Regress { // When the user explicitly filters, error if any matched test // has no expected output (they should use --add first) let output_names = - output_files.iter().map(|e| make_test_name(e)).collect::>(); + output_files.iter().map(make_test_name).collect::>(); for entry in &test_files { let name = make_test_name(entry); if !output_names.contains(&name) { @@ -577,7 +577,7 @@ impl Regress { } else { // Run setup.sql normally to establish schema/data let verbosity = &self.psql_verbosity.clone().unwrap_or("terse".into()); - run_tests(pg_config, pgregress_path, dbname, &[&setup_entry], verbosity, 0)?; + run_tests(pg_config, pgregress_path, dbname, &[setup_entry], verbosity, 0)?; } } @@ -633,17 +633,16 @@ impl Regress { // List test files (without setup, then report) let test_files = self.list_sql_tests(manifest_path, false)?; let output_files = self.list_expected_outputs(manifest_path, false)?; - let output_names = output_files.iter().map(|e| make_test_name(e)).collect::>(); + let output_names = output_files.iter().map(make_test_name).collect::>(); let mut ready = Vec::new(); let mut skipped = Vec::new(); for entry in &test_files { let name = make_test_name(entry); - if let Some(ref filter) = self.test_filter { - if !name.contains(filter) { + if let Some(ref filter) = self.test_filter + && !name.contains(filter) { continue; } - } if output_names.contains(&name) { ready.push(name); } else { @@ -767,7 +766,7 @@ fn pg_regress( use std::os::unix::fs::PermissionsExt; let launcher_script = - format!("#! /bin/bash\n$* -v VERBOSITY={}", verbosity.to_string(),).into_bytes(); + format!("#! /bin/bash\n$* -v VERBOSITY={}", verbosity,).into_bytes(); let path = temp_dir().join(format!("pgrx-pg_regress-runner-{}.sh", std::process::id())); let mut tmpfile = File::create(&path)?; @@ -837,12 +836,11 @@ fn print_regression_diffs(manifest_path: &Path, verbose: u8, run: u32, repeat: u return; } - if verbose >= 1 { - if let Ok(content) = std::fs::read_to_string(&diffs_path) { + if verbose >= 1 + && let Ok(content) = std::fs::read_to_string(&diffs_path) { eprintln!(); eprintln!("{content}"); } - } // When repeating, rename to regression..diffs so each run's output is preserved let final_path = if repeat > 1 { diff --git a/cargo-pgrx/src/command/run.rs b/cargo-pgrx/src/command/run.rs index 014dfb5ef1..d756962f07 100644 --- a/cargo-pgrx/src/command/run.rs +++ b/cargo-pgrx/src/command/run.rs @@ -60,7 +60,7 @@ pub(crate) struct Run { impl From<&Regress> for Run { fn from(regress: &Regress) -> Self { - Run { + Self { pg_version: regress.pg_version.clone(), dbname: regress.dbname.clone(), package: regress.package.clone(), @@ -87,11 +87,10 @@ impl Run { // If the first positional arg isn't a recognized PG version (pgXX) // and no dbname was given, treat it as a dbname - if let Some(ref v) = self.pg_version { - if !pgrx.is_feature_flag(v) && self.dbname.is_none() { + if let Some(ref v) = self.pg_version + && !pgrx.is_feature_flag(v) && self.dbname.is_none() { self.dbname = self.pg_version.take(); } - } let (package_manifest, package_manifest_path) = get_package_manifest( &self.features, diff --git a/cargo-pgrx/src/command/schema.rs b/cargo-pgrx/src/command/schema.rs index 789a251293..d46b2e83bb 100644 --- a/cargo-pgrx/src/command/schema.rs +++ b/cargo-pgrx/src/command/schema.rs @@ -212,7 +212,7 @@ pub(crate) fn generate_schema_implicit( .to_file(path) .wrap_err_with(|| format!("Could not write SQL to {}", path.display()))?; } else { - eprintln!("{} SQL entities to {}", " Writing".bold().green(), "/dev/stdout"); + eprintln!("{} SQL entities to /dev/stdout", " Writing".bold().green()); pgrx_sql.write(&mut std::io::stdout()).wrap_err("Could not write SQL to stdout")?; } diff --git a/cargo-pgrx/src/command/sudo_install.rs b/cargo-pgrx/src/command/sudo_install.rs index 42a852b03e..70ed4f3882 100644 --- a/cargo-pgrx/src/command/sudo_install.rs +++ b/cargo-pgrx/src/command/sudo_install.rs @@ -41,7 +41,7 @@ impl From for SudoInstall { impl From for Package { fn from(value: SudoInstall) -> Self { - Package { + Self { package: value.package, manifest_path: value.manifest_path, debug: !value.release, diff --git a/cargo-pgrx/src/command/test.rs b/cargo-pgrx/src/command/test.rs index 9eb753b9eb..36732952f1 100644 --- a/cargo-pgrx/src/command/test.rs +++ b/cargo-pgrx/src/command/test.rs @@ -96,11 +96,10 @@ impl CommandExecute for Test { // If the first positional arg isn't a recognized PG version (pgXX or "all") // and no testname was given, treat it as a testname filter - if let Some(ref v) = self.pg_version { - if v != "all" && !pgrx.is_feature_flag(v) && self.testname.is_none() { + if let Some(ref v) = self.pg_version + && v != "all" && !pgrx.is_feature_flag(v) && self.testname.is_none() { self.testname = self.pg_version.take(); } - } if self.pg_version.as_deref() == Some("all") { // run the tests for **all** the Postgres versions we know about diff --git a/cargo-pgrx/src/command/version.rs b/cargo-pgrx/src/command/version.rs index 2e4ebe312e..58c845d4b8 100644 --- a/cargo-pgrx/src/command/version.rs +++ b/cargo-pgrx/src/command/version.rs @@ -59,10 +59,7 @@ mod rss { let mut buf = Vec::new(); let _count = response.body_mut().as_reader().read_to_end(&mut buf)?; let body = String::from_utf8(buf)?; - let rss: Rss = match serde_xml_rs::from_str(&body) { - Ok(rss) => rss, - Err(e) => return Err(e.into()), - }; + let rss: Rss = serde_xml_rs::from_str(&body)?; let mut versions: BTreeMap = BTreeMap::from_iter( supported_versions.iter().map(|pgver| (pgver.major, pgver.clone())), diff --git a/cargo-pgrx/src/manifest.rs b/cargo-pgrx/src/manifest.rs index 576c3f6e4e..9471defd27 100644 --- a/cargo-pgrx/src/manifest.rs +++ b/cargo-pgrx/src/manifest.rs @@ -36,10 +36,10 @@ impl From for String { impl PgVersionSource { fn label(&self) -> &String { match self { - PgVersionSource::CliArgument(s) => s, - PgVersionSource::FeatureFlag(s) => s, - PgVersionSource::DefaultFeature(s) => s, - PgVersionSource::PgConfig(s) => s, + Self::CliArgument(s) => s, + Self::FeatureFlag(s) => s, + Self::DefaultFeature(s) => s, + Self::PgConfig(s) => s, } } } diff --git a/cargo-pgrx/src/object_utils.rs b/cargo-pgrx/src/object_utils.rs index a61713d080..0b7a24dfcb 100644 --- a/cargo-pgrx/src/object_utils.rs +++ b/cargo-pgrx/src/object_utils.rs @@ -225,7 +225,7 @@ fn target_architecture() -> object::Architecture { } } -fn slice_arch32<'a>(data: &'a [u8], arch: object::Architecture) -> Option<&'a [u8]> { +fn slice_arch32(data: &[u8], arch: object::Architecture) -> Option<&[u8]> { let candidates = MachOFatFile32::parse(data).ok()?; let architecture = candidates.arches().iter().find(|candidate| candidate.architecture() == arch)?; @@ -233,7 +233,7 @@ fn slice_arch32<'a>(data: &'a [u8], arch: object::Architecture) -> Option<&'a [u architecture.data(data).ok() } -fn slice_arch64<'a>(data: &'a [u8], arch: object::Architecture) -> Option<&'a [u8]> { +fn slice_arch64(data: &[u8], arch: object::Architecture) -> Option<&[u8]> { let candidates = MachOFatFile64::parse(data).ok()?; let architecture = candidates.arches().iter().find(|candidate| candidate.architecture() == arch)?; diff --git a/pgrx-bindgen/src/build.rs b/pgrx-bindgen/src/build.rs index f8baa5f879..aaf8015148 100644 --- a/pgrx-bindgen/src/build.rs +++ b/pgrx-bindgen/src/build.rs @@ -52,7 +52,7 @@ impl BindingOverride { fn new_from(enum_names: InnerMut) -> Self { // these cause duplicate definition problems on linux // see: https://github.com/rust-lang/rust-bindgen/issues/687 - BindingOverride { + Self { ignore_macros: HashSet::from_iter([ "FP_INFINITE", "FP_NAN", @@ -599,7 +599,7 @@ struct StructGraph<'a> { } impl<'a> From<&'a [syn::Item]> for StructGraph<'a> { - fn from(items: &'a [syn::Item]) -> StructGraph<'a> { + fn from(items: &'a [syn::Item]) -> Self { let mut descriptors = Vec::new(); // a table mapping struct names to their offset in `descriptors` diff --git a/pgrx-macros/src/rewriter.rs b/pgrx-macros/src/rewriter.rs index d8e0e86dac..04aa2b35da 100644 --- a/pgrx-macros/src/rewriter.rs +++ b/pgrx-macros/src/rewriter.rs @@ -56,7 +56,7 @@ pub fn item_fn_without_rewrite( // looking for this pattern: #[pg_guard(unsafe_entry_thread)] let unsafe_entry_thread = - attr.into_iter().find(|tt| tt.to_string() == "unsafe_entry_thread").is_some(); + attr.into_iter().any(|tt| tt.to_string() == "unsafe_entry_thread"); if sig.abi.clone().and_then(|abi| abi.name).is_none_or(|name| name.value() != "C-unwind") { panic!("#[pg_guard] must be combined with extern \"C-unwind\""); diff --git a/pgrx-pg-config/src/lib.rs b/pgrx-pg-config/src/lib.rs index b7bff4a781..ce915abfaf 100644 --- a/pgrx-pg-config/src/lib.rs +++ b/pgrx-pg-config/src/lib.rs @@ -76,10 +76,10 @@ pub enum PgMinorVersion { impl Display for PgMinorVersion { fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { match self { - PgMinorVersion::Latest => write!(f, ".LATEST"), - PgMinorVersion::Release(v) => write!(f, ".{v}"), - PgMinorVersion::Beta(v) => write!(f, "beta{v}"), - PgMinorVersion::Rc(v) => write!(f, "rc{v}"), + Self::Latest => write!(f, ".LATEST"), + Self::Release(v) => write!(f, ".{v}"), + Self::Beta(v) => write!(f, "beta{v}"), + Self::Rc(v) => write!(f, "rc{v}"), } } } @@ -87,8 +87,8 @@ impl Display for PgMinorVersion { impl PgMinorVersion { fn version(&self) -> Option { match self { - PgMinorVersion::Latest => None, - PgMinorVersion::Release(v) | PgMinorVersion::Beta(v) | PgMinorVersion::Rc(v) => { + Self::Latest => None, + Self::Release(v) | Self::Beta(v) | Self::Rc(v) => { Some(*v) } } @@ -103,8 +103,8 @@ pub struct PgVersion { } impl PgVersion { - pub const fn new(major: u16, minor: PgMinorVersion, url: Option) -> PgVersion { - PgVersion { major, minor, url } + pub const fn new(major: u16, minor: PgMinorVersion, url: Option) -> Self { + Self { major, minor, url } } pub fn minor(&self) -> Option { @@ -136,7 +136,7 @@ impl Display for PgConfig { impl Default for PgConfig { fn default() -> Self { - PgConfig { + Self { version: None, pg_config: None, known_props: None, @@ -149,13 +149,13 @@ impl Default for PgConfig { impl From for PgConfig { fn from(version: PgVersion) -> Self { - PgConfig { version: Some(version), pg_config: None, ..Default::default() } + Self { version: Some(version), pg_config: None, ..Default::default() } } } impl PgConfig { pub fn new(pg_config: PathBuf, base_port: u16, base_testing_port: u16) -> Self { - PgConfig { + Self { version: None, pg_config: Some(pg_config), known_props: None, @@ -166,7 +166,7 @@ impl PgConfig { } pub fn new_with_defaults(pg_config: PathBuf) -> Self { - PgConfig { + Self { version: None, pg_config: Some(pg_config), known_props: None, @@ -580,10 +580,10 @@ impl From for std::io::Error { fn from(value: PgrxHomeError) -> Self { match value { PgrxHomeError::NoHomeDirectory => { - std::io::Error::new(ErrorKind::NotFound, value.to_string()) + Self::new(ErrorKind::NotFound, value.to_string()) } PgrxHomeError::MissingPgrxHome(_) => { - std::io::Error::new(ErrorKind::NotFound, value.to_string()) + Self::new(ErrorKind::NotFound, value.to_string()) } PgrxHomeError::IoError(e) => e, } @@ -592,20 +592,20 @@ impl From for std::io::Error { impl Pgrx { pub fn new(base_port: u16, base_testing_port: u16) -> Self { - Pgrx { pg_configs: vec![], base_port, base_testing_port } + Self { pg_configs: vec![], base_port, base_testing_port } } pub fn from_config() -> eyre::Result { match std::env::var("PGRX_PG_CONFIG_PATH") { Ok(pg_config) => { // we have an environment variable that tells us the pg_config to use - let mut pgrx = Pgrx::default(); + let mut pgrx = Self::default(); pgrx.push(PgConfig::new(pg_config.into(), pgrx.base_port, pgrx.base_testing_port)); Ok(pgrx) } Err(_) => { // we'll get what we need from cargo-pgrx' config.toml file - let path = Pgrx::config_toml()?; + let path = Self::config_toml()?; if !path.try_exists()? { return Err(eyre!( "{} not found. Have you run `{}` yet?", @@ -616,7 +616,7 @@ impl Pgrx { match toml::from_str::(&std::fs::read_to_string(&path)?) { Ok(configs) => { - let mut pgrx = Pgrx::new( + let mut pgrx = Self::new( configs.base_port.unwrap_or(BASE_POSTGRES_PORT_NO), configs.base_testing_port.unwrap_or(BASE_POSTGRES_TESTING_PORT_NO), ); @@ -723,7 +723,7 @@ impl Pgrx { } pub fn config_toml() -> Result { - let mut path = Pgrx::home()?; + let mut path = Self::home()?; path.push("config.toml"); Ok(path) } diff --git a/pgrx-sql-entity-graph/src/aggregate/options.rs b/pgrx-sql-entity-graph/src/aggregate/options.rs index f35c208048..c2b85e1dbe 100644 --- a/pgrx-sql-entity-graph/src/aggregate/options.rs +++ b/pgrx-sql-entity-graph/src/aggregate/options.rs @@ -28,9 +28,9 @@ pub enum ParallelOption { impl ToSql for ParallelOption { fn to_sql(&self, _context: &PgrxSql) -> eyre::Result { let value = match self { - ParallelOption::Safe => String::from("SAFE"), - ParallelOption::Restricted => String::from("RESTRICTED"), - ParallelOption::Unsafe => String::from("UNSAFE"), + Self::Safe => String::from("SAFE"), + Self::Restricted => String::from("RESTRICTED"), + Self::Unsafe => String::from("UNSAFE"), }; Ok(value) } @@ -47,9 +47,9 @@ pub enum FinalizeModify { impl ToSql for FinalizeModify { fn to_sql(&self, _context: &PgrxSql) -> eyre::Result { let value = match self { - FinalizeModify::ReadOnly => String::from("READ_ONLY"), - FinalizeModify::Shareable => String::from("SHAREABLE"), - FinalizeModify::ReadWrite => String::from("READ_WRITE"), + Self::ReadOnly => String::from("READ_ONLY"), + Self::Shareable => String::from("SHAREABLE"), + Self::ReadWrite => String::from("READ_WRITE"), }; Ok(value) } diff --git a/pgrx-sql-entity-graph/src/composite_type.rs b/pgrx-sql-entity-graph/src/composite_type.rs index 5246e18214..384009cdd5 100644 --- a/pgrx-sql-entity-graph/src/composite_type.rs +++ b/pgrx-sql-entity-graph/src/composite_type.rs @@ -29,7 +29,7 @@ impl CompositeTypeMacro { /// Expands into the implementing type, explicitly eliding the lifetime /// if none is actually given. pub fn expand_with_lifetime(&self) -> syn::Type { - let CompositeTypeMacro { lifetime, span, .. } = self.clone(); + let Self { lifetime, span, .. } = self.clone(); let lifetime = lifetime.unwrap_or_else(|| syn::Lifetime::new("'_", span)); syn::parse_quote! { ::pgrx::heap_tuple::PgHeapTuple<#lifetime, ::pgrx::pgbox::AllocatedByRust> diff --git a/pgrx-sql-entity-graph/src/control_file.rs b/pgrx-sql-entity-graph/src/control_file.rs index 500668b2b9..1d653c526d 100644 --- a/pgrx-sql-entity-graph/src/control_file.rs +++ b/pgrx-sql-entity-graph/src/control_file.rs @@ -125,7 +125,7 @@ impl ControlFile { temp.insert(k, do_var_replacements(v.to_string(), cargo_version)?); } - let control_file = ControlFile { + let control_file = Self { comment: temp .get("comment") .ok_or(ControlFileError::MissingField { field: "comment" })? @@ -203,7 +203,7 @@ impl TryFrom for ControlFile { fn try_from(value: PathBuf) -> Result { let contents = std::fs::read_to_string(value)?; - ControlFile::try_from(contents.as_str()) + Self::try_from(contents.as_str()) } } diff --git a/pgrx-sql-entity-graph/src/extension_sql/entity.rs b/pgrx-sql-entity-graph/src/extension_sql/entity.rs index d78ebf9fb7..a880090889 100644 --- a/pgrx-sql-entity-graph/src/extension_sql/entity.rs +++ b/pgrx-sql-entity-graph/src/extension_sql/entity.rs @@ -132,13 +132,13 @@ pub enum SqlDeclaredEntity { impl Display for SqlDeclaredEntity { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - SqlDeclaredEntity::Type(data) => { + Self::Type(data) => { write!(f, "Type({})", data.name) } - SqlDeclaredEntity::Enum(data) => { + Self::Enum(data) => { write!(f, "Enum({})", data.name) } - SqlDeclaredEntity::Function(data) => { + Self::Function(data) => { write!(f, "Function({})", data.name) } } @@ -216,18 +216,18 @@ impl SqlDeclaredEntity { pub fn sql(&self) -> String { match self { - SqlDeclaredEntity::Type(data) => data.sql.clone(), - SqlDeclaredEntity::Enum(data) => data.sql.clone(), - SqlDeclaredEntity::Function(data) => data.sql.clone(), + Self::Type(data) => data.sql.clone(), + Self::Enum(data) => data.sql.clone(), + Self::Function(data) => data.sql.clone(), } } pub fn type_ident(&self) -> Option<&str> { match self { - SqlDeclaredEntity::Type(data) | SqlDeclaredEntity::Enum(data) => { + Self::Type(data) | Self::Enum(data) => { Some(data.type_ident.as_str()) } - SqlDeclaredEntity::Function(_) => None, + Self::Function(_) => None, } } @@ -237,14 +237,14 @@ impl SqlDeclaredEntity { pub fn has_sql_declared_entity(&self, identifier: &SqlDeclared) -> bool { match (&identifier, &self) { - (SqlDeclared::Type(ident_name), &SqlDeclaredEntity::Type(data)) - | (SqlDeclared::Enum(ident_name), &SqlDeclaredEntity::Enum(data)) => { + (SqlDeclared::Type(ident_name), &Self::Type(data)) + | (SqlDeclared::Enum(ident_name), &Self::Enum(data)) => { if ident_name == &data.name || ident_name == &data.type_ident { return true; } false } - (SqlDeclared::Function(ident_name), &SqlDeclaredEntity::Function(data)) => { + (SqlDeclared::Function(ident_name), &Self::Function(data)) => { ident_name == &data.name } _ => false, diff --git a/pgrx-sql-entity-graph/src/extension_sql/mod.rs b/pgrx-sql-entity-graph/src/extension_sql/mod.rs index a3c5c259f3..37368c3a2c 100644 --- a/pgrx-sql-entity-graph/src/extension_sql/mod.rs +++ b/pgrx-sql-entity-graph/src/extension_sql/mod.rs @@ -155,7 +155,7 @@ impl Parse for CodeEnrichment { let path = input.parse()?; let _after_sql_comma: Option = input.parse()?; let attrs = input.parse_terminated(ExtensionSqlAttribute::parse, Token![,])?; - Ok(CodeEnrichment(ExtensionSqlFile { path, attrs })) + Ok(Self(ExtensionSqlFile { path, attrs })) } } @@ -284,7 +284,7 @@ impl Parse for CodeEnrichment { }); let name = name.ok_or_else(|| syn::Error::new(input.span(), "expected `name` to be set"))?; - Ok(CodeEnrichment(ExtensionSql { sql, attrs, name })) + Ok(Self(ExtensionSql { sql, attrs, name })) } } @@ -346,20 +346,20 @@ pub enum SqlDeclared { impl ToEntityGraphTokens for SqlDeclared { fn to_entity_graph_tokens(&self) -> TokenStream2 { let (variant, identifier) = match &self { - SqlDeclared::Type(val) => ("Type", val), - SqlDeclared::Enum(val) => ("Enum", val), - SqlDeclared::Function(val) => ("Function", val), + Self::Type(val) => ("Type", val), + Self::Enum(val) => ("Enum", val), + Self::Function(val) => ("Function", val), }; let identifier_expr = self.section_identifier_tokens(); match self { - SqlDeclared::Type(_) | SqlDeclared::Enum(_) => { + Self::Type(_) | Self::Enum(_) => { let identifier_path: syn::Path = syn::parse_str(identifier).expect("type declaration path should parse"); quote! { ::pgrx::pgrx_sql_entity_graph::SqlDeclaredEntity::build_type::<#identifier_path>(#variant, #identifier_expr).unwrap() } } - SqlDeclared::Function(_) => quote! { + Self::Function(_) => quote! { ::pgrx::pgrx_sql_entity_graph::SqlDeclaredEntity::build(#variant, #identifier_expr).unwrap() }, } @@ -371,7 +371,7 @@ impl ToRustCodeTokens for SqlDeclared {} impl SqlDeclared { fn section_identifier_tokens(&self) -> TokenStream2 { let identifier = match self { - SqlDeclared::Type(value) | SqlDeclared::Enum(value) | SqlDeclared::Function(value) => { + Self::Type(value) | Self::Enum(value) | Self::Function(value) => { value } }; @@ -388,7 +388,7 @@ impl SqlDeclared { pub fn section_len_tokens(&self) -> TokenStream2 { let identifier_expr = self.section_identifier_tokens(); match self { - SqlDeclared::Type(identifier) | SqlDeclared::Enum(identifier) => { + Self::Type(identifier) | Self::Enum(identifier) => { let identifier_path: syn::Path = syn::parse_str(identifier).expect("type declaration path should parse"); quote! { @@ -402,7 +402,7 @@ impl SqlDeclared { ) } } - SqlDeclared::Function(_) => quote! { + Self::Function(_) => quote! { ::pgrx::pgrx_sql_entity_graph::section::u8_len() + ::pgrx::pgrx_sql_entity_graph::section::str_len(#identifier_expr) }, @@ -412,7 +412,7 @@ impl SqlDeclared { pub fn section_writer_tokens(&self, writer: TokenStream2) -> TokenStream2 { let identifier_expr = self.section_identifier_tokens(); match self { - SqlDeclared::Type(identifier) => { + Self::Type(identifier) => { let identifier_path: syn::Path = syn::parse_str(identifier).expect("type declaration path should parse"); quote! { @@ -423,7 +423,7 @@ impl SqlDeclared { .argument_sql(<#identifier_path as ::pgrx::pgrx_sql_entity_graph::metadata::SqlTranslatable>::ARGUMENT_SQL) } } - SqlDeclared::Enum(identifier) => { + Self::Enum(identifier) => { let identifier_path: syn::Path = syn::parse_str(identifier).expect("type declaration path should parse"); quote! { @@ -434,7 +434,7 @@ impl SqlDeclared { .argument_sql(<#identifier_path as ::pgrx::pgrx_sql_entity_graph::metadata::SqlTranslatable>::ARGUMENT_SQL) } } - SqlDeclared::Function(_) => quote! { + Self::Function(_) => quote! { #writer .u8(::pgrx::pgrx_sql_entity_graph::section::SQL_DECLARED_FUNCTION) .str(#identifier_expr) @@ -457,9 +457,9 @@ impl Parse for SqlDeclared { identifier_segments.join("::") }; let this = match variant.to_string().as_str() { - "Type" => SqlDeclared::Type(identifier_str), - "Enum" => SqlDeclared::Enum(identifier_str), - "Function" => SqlDeclared::Function(identifier_str), + "Type" => Self::Type(identifier_str), + "Enum" => Self::Enum(identifier_str), + "Function" => Self::Function(identifier_str), _ => { return Err(syn::Error::new( variant.span(), diff --git a/pgrx-sql-entity-graph/src/extern_args.rs b/pgrx-sql-entity-graph/src/extern_args.rs index 169aeb191a..b589e63c0b 100644 --- a/pgrx-sql-entity-graph/src/extern_args.rs +++ b/pgrx-sql-entity-graph/src/extern_args.rs @@ -37,24 +37,24 @@ pub enum ExternArgs { impl core::fmt::Display for ExternArgs { fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { match self { - ExternArgs::CreateOrReplace => write!(f, "CREATE OR REPLACE"), - ExternArgs::Immutable => write!(f, "IMMUTABLE"), - ExternArgs::Strict => write!(f, "STRICT"), - ExternArgs::Stable => write!(f, "STABLE"), - ExternArgs::Volatile => write!(f, "VOLATILE"), - ExternArgs::Raw => Ok(()), - ExternArgs::ParallelSafe => write!(f, "PARALLEL SAFE"), - ExternArgs::ParallelUnsafe => write!(f, "PARALLEL UNSAFE"), - ExternArgs::SecurityDefiner => write!(f, "SECURITY DEFINER"), - ExternArgs::SecurityInvoker => write!(f, "SECURITY INVOKER"), - ExternArgs::ParallelRestricted => write!(f, "PARALLEL RESTRICTED"), - ExternArgs::Support(item) => write!(f, "{item}"), - ExternArgs::ShouldPanic(_) => Ok(()), - ExternArgs::NoGuard => Ok(()), - ExternArgs::Schema(_) => Ok(()), - ExternArgs::Name(_) => Ok(()), - ExternArgs::Cost(cost) => write!(f, "COST {cost}"), - ExternArgs::Requires(_) => Ok(()), + Self::CreateOrReplace => write!(f, "CREATE OR REPLACE"), + Self::Immutable => write!(f, "IMMUTABLE"), + Self::Strict => write!(f, "STRICT"), + Self::Stable => write!(f, "STABLE"), + Self::Volatile => write!(f, "VOLATILE"), + Self::Raw => Ok(()), + Self::ParallelSafe => write!(f, "PARALLEL SAFE"), + Self::ParallelUnsafe => write!(f, "PARALLEL UNSAFE"), + Self::SecurityDefiner => write!(f, "SECURITY DEFINER"), + Self::SecurityInvoker => write!(f, "SECURITY INVOKER"), + Self::ParallelRestricted => write!(f, "PARALLEL RESTRICTED"), + Self::Support(item) => write!(f, "{item}"), + Self::ShouldPanic(_) => Ok(()), + Self::NoGuard => Ok(()), + Self::Schema(_) => Ok(()), + Self::Name(_) => Ok(()), + Self::Cost(cost) => write!(f, "COST {cost}"), + Self::Requires(_) => Ok(()), } } } @@ -62,34 +62,34 @@ impl core::fmt::Display for ExternArgs { impl ExternArgs { pub fn section_len_tokens(&self) -> TokenStream { match self { - ExternArgs::CreateOrReplace - | ExternArgs::Immutable - | ExternArgs::Strict - | ExternArgs::Stable - | ExternArgs::Volatile - | ExternArgs::Raw - | ExternArgs::NoGuard - | ExternArgs::SecurityDefiner - | ExternArgs::SecurityInvoker - | ExternArgs::ParallelSafe - | ExternArgs::ParallelUnsafe - | ExternArgs::ParallelRestricted => { + Self::CreateOrReplace + | Self::Immutable + | Self::Strict + | Self::Stable + | Self::Volatile + | Self::Raw + | Self::NoGuard + | Self::SecurityDefiner + | Self::SecurityInvoker + | Self::ParallelSafe + | Self::ParallelUnsafe + | Self::ParallelRestricted => { quote! { ::pgrx::pgrx_sql_entity_graph::section::u8_len() } } - ExternArgs::ShouldPanic(value) - | ExternArgs::Schema(value) - | ExternArgs::Name(value) - | ExternArgs::Cost(value) => quote! { + Self::ShouldPanic(value) + | Self::Schema(value) + | Self::Name(value) + | Self::Cost(value) => quote! { ::pgrx::pgrx_sql_entity_graph::section::u8_len() + ::pgrx::pgrx_sql_entity_graph::section::str_len(#value) }, - ExternArgs::Support(item) => { + Self::Support(item) => { let item_len = item.section_len_tokens(); quote! { ::pgrx::pgrx_sql_entity_graph::section::u8_len() + (#item_len) } } - ExternArgs::Requires(items) => { + Self::Requires(items) => { let item_lens = items.iter().map(PositioningRef::section_len_tokens); quote! { ::pgrx::pgrx_sql_entity_graph::section::u8_len() @@ -103,66 +103,66 @@ impl ExternArgs { pub fn section_writer_tokens(&self, writer: TokenStream) -> TokenStream { match self { - ExternArgs::CreateOrReplace => { + Self::CreateOrReplace => { quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_CREATE_OR_REPLACE) } } - ExternArgs::Immutable => { + Self::Immutable => { quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_IMMUTABLE) } } - ExternArgs::Strict => { + Self::Strict => { quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_STRICT) } } - ExternArgs::Stable => { + Self::Stable => { quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_STABLE) } } - ExternArgs::Volatile => { + Self::Volatile => { quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_VOLATILE) } } - ExternArgs::Raw => { + Self::Raw => { quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_RAW) } } - ExternArgs::NoGuard => { + Self::NoGuard => { quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_NO_GUARD) } } - ExternArgs::SecurityDefiner => quote! { + Self::SecurityDefiner => quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_SECURITY_DEFINER) }, - ExternArgs::SecurityInvoker => quote! { + Self::SecurityInvoker => quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_SECURITY_INVOKER) }, - ExternArgs::ParallelSafe => quote! { + Self::ParallelSafe => quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_PARALLEL_SAFE) }, - ExternArgs::ParallelUnsafe => quote! { + Self::ParallelUnsafe => quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_PARALLEL_UNSAFE) }, - ExternArgs::ParallelRestricted => quote! { + Self::ParallelRestricted => quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_PARALLEL_RESTRICTED) }, - ExternArgs::ShouldPanic(value) => quote! { + Self::ShouldPanic(value) => quote! { #writer .u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_SHOULD_PANIC) .str(#value) }, - ExternArgs::Schema(value) => quote! { + Self::Schema(value) => quote! { #writer .u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_SCHEMA) .str(#value) }, - ExternArgs::Support(item) => item.section_writer_tokens(quote! { + Self::Support(item) => item.section_writer_tokens(quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_SUPPORT) }), - ExternArgs::Name(value) => quote! { + Self::Name(value) => quote! { #writer .u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_NAME) .str(#value) }, - ExternArgs::Cost(value) => quote! { + Self::Cost(value) => quote! { #writer .u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_ARG_COST) .str(#value) }, - ExternArgs::Requires(items) => { + Self::Requires(items) => { let writer_ident = Ident::new("__pgrx_schema_writer", Span::mixed_site()); let item_writers = items.iter().map(|item| item.section_writer_tokens(quote! { #writer_ident })); @@ -184,24 +184,24 @@ impl ExternArgs { impl ToTokens for ExternArgs { fn to_tokens(&self, tokens: &mut TokenStream) { match self { - ExternArgs::CreateOrReplace => tokens.append(format_ident!("CreateOrReplace")), - ExternArgs::Immutable => tokens.append(format_ident!("Immutable")), - ExternArgs::Strict => tokens.append(format_ident!("Strict")), - ExternArgs::Stable => tokens.append(format_ident!("Stable")), - ExternArgs::Volatile => tokens.append(format_ident!("Volatile")), - ExternArgs::Raw => tokens.append(format_ident!("Raw")), - ExternArgs::NoGuard => tokens.append(format_ident!("NoGuard")), - ExternArgs::SecurityDefiner => tokens.append(format_ident!("SecurityDefiner")), - ExternArgs::SecurityInvoker => tokens.append(format_ident!("SecurityInvoker")), - ExternArgs::ParallelSafe => tokens.append(format_ident!("ParallelSafe")), - ExternArgs::ParallelUnsafe => tokens.append(format_ident!("ParallelUnsafe")), - ExternArgs::ParallelRestricted => tokens.append(format_ident!("ParallelRestricted")), - ExternArgs::ShouldPanic(_s) => tokens.append_all(quote! { Error(String::from("#_s")) }), - ExternArgs::Schema(_s) => tokens.append_all(quote! { Schema(String::from("#_s")) }), - ExternArgs::Support(item) => tokens.append_all(quote! { Support(#item) }), - ExternArgs::Name(_s) => tokens.append_all(quote! { Name(String::from("#_s")) }), - ExternArgs::Cost(_s) => tokens.append_all(quote! { Cost(String::from("#_s")) }), - ExternArgs::Requires(items) => { + Self::CreateOrReplace => tokens.append(format_ident!("CreateOrReplace")), + Self::Immutable => tokens.append(format_ident!("Immutable")), + Self::Strict => tokens.append(format_ident!("Strict")), + Self::Stable => tokens.append(format_ident!("Stable")), + Self::Volatile => tokens.append(format_ident!("Volatile")), + Self::Raw => tokens.append(format_ident!("Raw")), + Self::NoGuard => tokens.append(format_ident!("NoGuard")), + Self::SecurityDefiner => tokens.append(format_ident!("SecurityDefiner")), + Self::SecurityInvoker => tokens.append(format_ident!("SecurityInvoker")), + Self::ParallelSafe => tokens.append(format_ident!("ParallelSafe")), + Self::ParallelUnsafe => tokens.append(format_ident!("ParallelUnsafe")), + Self::ParallelRestricted => tokens.append(format_ident!("ParallelRestricted")), + Self::ShouldPanic(_s) => tokens.append_all(quote! { Error(String::from("#_s")) }), + Self::Schema(_s) => tokens.append_all(quote! { Schema(String::from("#_s")) }), + Self::Support(item) => tokens.append_all(quote! { Support(#item) }), + Self::Name(_s) => tokens.append_all(quote! { Name(String::from("#_s")) }), + Self::Cost(_s) => tokens.append_all(quote! { Cost(String::from("#_s")) }), + Self::Requires(items) => { tokens.append_all(quote! { Requires(vec![#(#items),*]) }) } } diff --git a/pgrx-sql-entity-graph/src/fmt.rs b/pgrx-sql-entity-graph/src/fmt.rs index cf8622d726..217dd1d41c 100644 --- a/pgrx-sql-entity-graph/src/fmt.rs +++ b/pgrx-sql-entity-graph/src/fmt.rs @@ -31,7 +31,7 @@ impl ErrHarder for syn::Result { } impl ErrHarder for syn::Error { - fn more_error(mut self, closerr: impl FnOnce() -> syn::Error) -> Self { + fn more_error(mut self, closerr: impl FnOnce() -> Self) -> Self { self.combine(closerr()); self } diff --git a/pgrx-sql-entity-graph/src/metadata/sql_translatable.rs b/pgrx-sql-entity-graph/src/metadata/sql_translatable.rs index 7046549166..bb5234b525 100644 --- a/pgrx-sql-entity-graph/src/metadata/sql_translatable.rs +++ b/pgrx-sql-entity-graph/src/metadata/sql_translatable.rs @@ -53,8 +53,8 @@ pub enum SqlMapping { } impl SqlMapping { - pub fn literal(s: &'static str) -> SqlMapping { - SqlMapping::As(String::from(s)) + pub fn literal(s: &'static str) -> Self { + Self::As(String::from(s)) } } @@ -108,11 +108,11 @@ pub(crate) fn numeric_sql_string(precision: Option, scale: Option) -> impl From for SqlArrayMapping { fn from(value: SqlArrayMappingRef) -> Self { match value { - SqlArrayMappingRef::As(value) => SqlArrayMapping::As(String::from(value)), + SqlArrayMappingRef::As(value) => Self::As(String::from(value)), SqlArrayMappingRef::Numeric { precision, scale } => { - SqlArrayMapping::As(numeric_sql_string(precision, scale)) + Self::As(numeric_sql_string(precision, scale)) } - SqlArrayMappingRef::Composite => SqlArrayMapping::Composite, + SqlArrayMappingRef::Composite => Self::Composite, } } } @@ -120,13 +120,13 @@ impl From for SqlArrayMapping { impl From for SqlMapping { fn from(value: SqlMappingRef) -> Self { match value { - SqlMappingRef::As(value) => SqlMapping::literal(value), + SqlMappingRef::As(value) => Self::literal(value), SqlMappingRef::Numeric { precision, scale } => { - SqlMapping::As(numeric_sql_string(precision, scale)) + Self::As(numeric_sql_string(precision, scale)) } - SqlMappingRef::Composite => SqlMapping::Composite, - SqlMappingRef::Array(value) => SqlMapping::Array(value.into()), - SqlMappingRef::Skip => SqlMapping::Skip, + SqlMappingRef::Composite => Self::Composite, + SqlMappingRef::Array(value) => Self::Array(value.into()), + SqlMappingRef::Skip => Self::Skip, } } } @@ -142,10 +142,10 @@ pub enum ReturnsRef { impl From for Returns { fn from(value: ReturnsRef) -> Self { match value { - ReturnsRef::One(value) => Returns::One(value.into()), - ReturnsRef::SetOf(value) => Returns::SetOf(value.into()), + ReturnsRef::One(value) => Self::One(value.into()), + ReturnsRef::SetOf(value) => Self::SetOf(value.into()), ReturnsRef::Table(values) => { - Returns::Table(values.iter().copied().map(Into::into).collect()) + Self::Table(values.iter().copied().map(Into::into).collect()) } } } diff --git a/pgrx-sql-entity-graph/src/pg_extern/argument.rs b/pgrx-sql-entity-graph/src/pg_extern/argument.rs index 28260b31cb..d1d02ffe40 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/argument.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/argument.rs @@ -58,7 +58,7 @@ impl PgExternArgument { let used_ty = UsedType::new(*value.ty)?; - Ok(PgExternArgument { fn_arg, pat: identifier, used_ty }) + Ok(Self { fn_arg, pat: identifier, used_ty }) } pub fn entity_tokens(&self) -> TokenStream2 { diff --git a/pgrx-sql-entity-graph/src/pg_extern/attribute.rs b/pgrx-sql-entity-graph/src/pg_extern/attribute.rs index a1a4b2c2b3..9275b50a5a 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/attribute.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/attribute.rs @@ -50,49 +50,49 @@ pub enum Attribute { impl ToTokens for Attribute { fn to_tokens(&self, tokens: &mut TokenStream2) { let quoted = match self { - Attribute::Immutable => quote! { immutable }, - Attribute::Strict => quote! { strict }, - Attribute::Stable => quote! { stable }, - Attribute::Volatile => quote! { volatile }, - Attribute::Raw => quote! { raw }, - Attribute::NoGuard => quote! { no_guard }, - Attribute::CreateOrReplace => quote! { create_or_replace }, - Attribute::SecurityDefiner => { + Self::Immutable => quote! { immutable }, + Self::Strict => quote! { strict }, + Self::Stable => quote! { stable }, + Self::Volatile => quote! { volatile }, + Self::Raw => quote! { raw }, + Self::NoGuard => quote! { no_guard }, + Self::CreateOrReplace => quote! { create_or_replace }, + Self::SecurityDefiner => { quote! {security_definer} } - Attribute::SecurityInvoker => { + Self::SecurityInvoker => { quote! {security_invoker} } - Attribute::ParallelSafe => { + Self::ParallelSafe => { quote! { parallel_safe } } - Attribute::ParallelUnsafe => { + Self::ParallelUnsafe => { quote! { parallel_unsafe } } - Attribute::ParallelRestricted => { + Self::ParallelRestricted => { quote! { parallel_restricted } } - Attribute::ShouldPanic(s) => { + Self::ShouldPanic(s) => { quote! { expected = #s } } - Attribute::Schema(s) => { + Self::Schema(s) => { quote! { schema = #s } } - Attribute::Support(item) => { + Self::Support(item) => { quote! { support = #item } } - Attribute::Name(s) => { + Self::Name(s) => { quote! { name = #s } } - Attribute::Cost(s) => { + Self::Cost(s) => { quote! { cost = #s } } - Attribute::Requires(items) => { + Self::Requires(items) => { let items_iter = items.iter().map(|x| x.to_token_stream()).collect::>(); quote! { requires = [#(#items_iter),*] } } // This attribute is handled separately - Attribute::Sql(to_sql_config) => { + Self::Sql(to_sql_config) => { quote! { sql = #to_sql_config } } }; @@ -119,12 +119,12 @@ impl Parse for Attribute { "error" | "expected" => { let _eq: Token![=] = input.parse()?; let literal: syn::LitStr = input.parse()?; - Attribute::ShouldPanic(literal) + Self::ShouldPanic(literal) } "schema" => { let _eq: Token![=] = input.parse()?; let literal: syn::LitStr = input.parse()?; - Attribute::Schema(literal) + Self::Schema(literal) } "support" => { let _eq: Token![=] = input.parse()?; diff --git a/pgrx-sql-entity-graph/src/pg_extern/cast.rs b/pgrx-sql-entity-graph/src/pg_extern/cast.rs index 596a243294..ce0920463d 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/cast.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/cast.rs @@ -49,13 +49,13 @@ impl TryFrom for PgCast { impl ToTokens for PgCast { fn to_tokens(&self, tokens: &mut TokenStream2) { let quoted = match self { - PgCast::Default => quote! { + Self::Default => quote! { ::pgrx::pgrx_sql_entity_graph::PgCastEntity::Default }, - PgCast::Assignment => quote! { + Self::Assignment => quote! { ::pgrx::pgrx_sql_entity_graph::PgCastEntity::Assignment }, - PgCast::Implicit => quote! { + Self::Implicit => quote! { ::pgrx::pgrx_sql_entity_graph::PgCastEntity::Implicit }, }; @@ -70,13 +70,13 @@ impl PgCast { pub fn section_writer_tokens(&self, writer: TokenStream2) -> TokenStream2 { match self { - PgCast::Default => quote! { + Self::Default => quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::OPERATOR_CAST_DEFAULT) }, - PgCast::Assignment => quote! { + Self::Assignment => quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::OPERATOR_CAST_ASSIGNMENT) }, - PgCast::Implicit => quote! { + Self::Implicit => quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::OPERATOR_CAST_IMPLICIT) }, } diff --git a/pgrx-sql-entity-graph/src/pg_extern/mod.rs b/pgrx-sql-entity-graph/src/pg_extern/mod.rs index 2f4a86fe97..906fa69bbc 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/mod.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/mod.rs @@ -149,7 +149,7 @@ impl PgExtern { } /// Returns a new instance of this `PgExtern` with `cast` overwritten to `pg_cast`. - pub fn as_cast(&self, pg_cast: PgCast) -> PgExtern { + pub fn as_cast(&self, pg_cast: PgCast) -> Self { let mut result = self.clone(); result.cast = Some(pg_cast); result @@ -549,7 +549,7 @@ trait LastIdent { impl LastIdent for syn::Type { #[inline] fn filter_last_ident(&self, id: &str) -> Option<&syn::PathSegment> { - let syn::Type::Path(syn::TypePath { path, .. }) = self else { return None }; + let Self::Path(syn::TypePath { path, .. }) = self else { return None }; path.filter_last_ident(id) } } diff --git a/pgrx-sql-entity-graph/src/pg_extern/operator.rs b/pgrx-sql-entity-graph/src/pg_extern/operator.rs index d0ffc4c453..c264ce1a35 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/operator.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/operator.rs @@ -139,7 +139,7 @@ pub struct PgrxOperatorAttributeWithIdent { impl Parse for PgrxOperatorAttributeWithIdent { fn parse(input: &ParseBuffer) -> Result { - Ok(PgrxOperatorAttributeWithIdent { fn_name: input.parse()? }) + Ok(Self { fn_name: input.parse()? }) } } @@ -161,7 +161,7 @@ pub struct PgrxOperatorOpName { impl Parse for PgrxOperatorOpName { fn parse(input: &ParseBuffer) -> Result { - Ok(PgrxOperatorOpName { op_name: input.parse()? }) + Ok(Self { op_name: input.parse()? }) } } diff --git a/pgrx-sql-entity-graph/src/pg_extern/returning.rs b/pgrx-sql-entity-graph/src/pg_extern/returning.rs index 8de5268e7d..bc0648f28d 100644 --- a/pgrx-sql-entity-graph/src/pg_extern/returning.rs +++ b/pgrx-sql-entity-graph/src/pg_extern/returning.rs @@ -42,12 +42,12 @@ pub enum Returning { } impl Returning { - fn parse_type_macro(type_macro: &mut syn::TypeMacro) -> Result { + fn parse_type_macro(type_macro: &mut syn::TypeMacro) -> Result { let mac = &type_macro.mac; let opt_archetype = mac.path.segments.last().map(|archetype| archetype.ident.to_string()); match opt_archetype.as_deref() { Some("composite_type") => { - Ok(Returning::Type(UsedType::new(syn::Type::Macro(type_macro.clone()))?)) + Ok(Self::Type(UsedType::new(syn::Type::Macro(type_macro.clone()))?)) } _ => Err(syn::Error::new( type_macro.span(), @@ -56,7 +56,7 @@ impl Returning { } } - fn match_type(ty: &Type) -> Result { + fn match_type(ty: &Type) -> Result { let mut ty = Box::new(ty.clone()); match &mut *ty { @@ -79,7 +79,7 @@ impl Returning { Some(syn::GenericArgument::Type(_)) => { let used_ty = UsedType::new(syn::Type::Path(typepath.clone()))?; - return Ok(Returning::Type(used_ty)); + return Ok(Self::Type(used_ty)); } other => { return Err(syn::Error::new( @@ -167,7 +167,7 @@ impl Returning { )); } }; - Ok(Returning::SetOf { ty: used_ty }) + Ok(Self::SetOf { ty: used_ty }) } else if is_table_iter { let last_path_segment = segments.last_mut().unwrap(); let mut iterated_items = vec![]; @@ -250,19 +250,19 @@ impl Returning { )); } }; - Ok(Returning::Iterated { tys: iterated_items }) + Ok(Self::Iterated { tys: iterated_items }) } else { let used_ty = UsedType::new(syn::Type::Path(typepath.clone()))?; - Ok(Returning::Type(used_ty)) + Ok(Self::Type(used_ty)) } } else { let used_ty = UsedType::new(syn::Type::Path(typepath.clone()))?; - Ok(Returning::Type(used_ty)) + Ok(Self::Type(used_ty)) } } syn::Type::Reference(ty_ref) => { let used_ty = UsedType::new(syn::Type::Reference(ty_ref.clone()))?; - Ok(Returning::Type(used_ty)) + Ok(Self::Type(used_ty)) } syn::Type::Macro(type_macro) => Self::parse_type_macro(type_macro), syn::Type::Paren(type_paren) => match &mut *type_paren.elem { @@ -286,7 +286,7 @@ impl TryFrom<&syn::ReturnType> for Returning { fn try_from(value: &syn::ReturnType) -> Result { match &value { - syn::ReturnType::Default => Ok(Returning::None), + syn::ReturnType::Default => Ok(Self::None), syn::ReturnType::Type(_, ty) => Self::match_type(ty), } } @@ -295,10 +295,10 @@ impl TryFrom<&syn::ReturnType> for Returning { impl ToTokens for Returning { fn to_tokens(&self, tokens: &mut TokenStream2) { let quoted = match self { - Returning::None => quote! { + Self::None => quote! { ::pgrx::pgrx_sql_entity_graph::PgExternReturnEntity::None }, - Returning::Type(used_ty) => { + Self::Type(used_ty) => { let used_ty_entity_tokens = used_ty.entity_tokens(); quote! { ::pgrx::pgrx_sql_entity_graph::PgExternReturnEntity::Type { @@ -306,7 +306,7 @@ impl ToTokens for Returning { } } } - Returning::SetOf { ty: used_ty } => { + Self::SetOf { ty: used_ty } => { let used_ty_entity_tokens = used_ty.entity_tokens(); quote! { ::pgrx::pgrx_sql_entity_graph::PgExternReturnEntity::SetOf { @@ -314,7 +314,7 @@ impl ToTokens for Returning { } } } - Returning::Iterated { tys: items } => { + Self::Iterated { tys: items } => { let quoted_items = items .iter() .map(|ReturningIteratedItem { used_ty, name }| { @@ -344,20 +344,20 @@ impl ToTokens for Returning { impl Returning { pub fn section_len_tokens(&self) -> TokenStream2 { match self { - Returning::None => quote! { ::pgrx::pgrx_sql_entity_graph::section::u8_len() }, - Returning::Type(used_ty) => { + Self::None => quote! { ::pgrx::pgrx_sql_entity_graph::section::u8_len() }, + Self::Type(used_ty) => { let used_ty_len = used_ty.section_len_tokens(); quote! { ::pgrx::pgrx_sql_entity_graph::section::u8_len() + (#used_ty_len) } } - Returning::SetOf { ty } => { + Self::SetOf { ty } => { let used_ty_len = ty.section_len_tokens(); quote! { ::pgrx::pgrx_sql_entity_graph::section::u8_len() + (#used_ty_len) } } - Returning::Iterated { tys: items } => { + Self::Iterated { tys: items } => { let item_lens = items.iter().map(|ReturningIteratedItem { used_ty, name }| { let used_ty_len = used_ty.section_len_tokens(); let name_len = name @@ -385,16 +385,16 @@ impl Returning { pub fn section_writer_tokens(&self, writer: TokenStream2) -> TokenStream2 { match self { - Returning::None => quote! { + Self::None => quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_RET_NONE) }, - Returning::Type(used_ty) => used_ty.section_writer_tokens(quote! { + Self::Type(used_ty) => used_ty.section_writer_tokens(quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_RET_TYPE) }), - Returning::SetOf { ty } => ty.section_writer_tokens(quote! { + Self::SetOf { ty } => ty.section_writer_tokens(quote! { #writer.u8(::pgrx::pgrx_sql_entity_graph::section::EXTERN_RET_SET_OF) }), - Returning::Iterated { tys: items } => { + Self::Iterated { tys: items } => { let item_count = items.len(); let writer_ident = Ident::new("__pgrx_schema_writer", Span::mixed_site()); let item_writers = items.iter().map(|ReturningIteratedItem { used_ty, name }| { diff --git a/pgrx-sql-entity-graph/src/pg_trigger/mod.rs b/pgrx-sql-entity-graph/src/pg_trigger/mod.rs index 99161af191..ad4b7fc1b0 100644 --- a/pgrx-sql-entity-graph/src/pg_trigger/mod.rs +++ b/pgrx-sql-entity-graph/src/pg_trigger/mod.rs @@ -65,7 +65,7 @@ impl PgTrigger { crate::ident_is_acceptable_to_postgres(&func.sig.ident)?; } - Ok(CodeEnrichment(PgTrigger { func, to_sql_config })) + Ok(CodeEnrichment(Self { func, to_sql_config })) } pub fn wrapper_tokens(&self) -> Result { diff --git a/pgrx-sql-entity-graph/src/positioning_ref.rs b/pgrx-sql-entity-graph/src/positioning_ref.rs index b36f32aa5a..a6beeaf1eb 100644 --- a/pgrx-sql-entity-graph/src/positioning_ref.rs +++ b/pgrx-sql-entity-graph/src/positioning_ref.rs @@ -28,8 +28,8 @@ pub enum PositioningRef { impl Display for PositioningRef { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - PositioningRef::FullPath(i) => f.write_str(i), - PositioningRef::Name(i) => f.write_str(i), + Self::FullPath(i) => f.write_str(i), + Self::Name(i) => f.write_str(i), } } } @@ -51,7 +51,7 @@ impl Parse for PositioningRef { impl PositioningRef { pub fn section_len_tokens(&self) -> proc_macro2::TokenStream { match self { - PositioningRef::FullPath(item) | PositioningRef::Name(item) => quote! { + Self::FullPath(item) | Self::Name(item) => quote! { ::pgrx::pgrx_sql_entity_graph::section::u8_len() + ::pgrx::pgrx_sql_entity_graph::section::str_len(#item) }, @@ -63,12 +63,12 @@ impl PositioningRef { writer: proc_macro2::TokenStream, ) -> proc_macro2::TokenStream { match self { - PositioningRef::FullPath(item) => quote! { + Self::FullPath(item) => quote! { #writer .u8(::pgrx::pgrx_sql_entity_graph::section::POSITIONING_REF_FULL_PATH) .str(#item) }, - PositioningRef::Name(item) => quote! { + Self::Name(item) => quote! { #writer .u8(::pgrx::pgrx_sql_entity_graph::section::POSITIONING_REF_NAME) .str(#item) @@ -80,10 +80,10 @@ impl PositioningRef { impl ToTokens for PositioningRef { fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) { let toks = match self { - PositioningRef::FullPath(item) => quote! { + Self::FullPath(item) => quote! { ::pgrx::pgrx_sql_entity_graph::PositioningRef::FullPath(String::from(#item)) }, - PositioningRef::Name(item) => quote! { + Self::Name(item) => quote! { ::pgrx::pgrx_sql_entity_graph::PositioningRef::Name(String::from(#item)) }, }; diff --git a/pgrx-sql-entity-graph/src/postgres_type/entity.rs b/pgrx-sql-entity-graph/src/postgres_type/entity.rs index 1d201bffae..bccccc60ac 100644 --- a/pgrx-sql-entity-graph/src/postgres_type/entity.rs +++ b/pgrx-sql-entity-graph/src/postgres_type/entity.rs @@ -38,8 +38,8 @@ const INVALID_ATTR_CONTENT: &str = impl ToTokens for Alignment { fn to_tokens(&self, tokens: &mut TokenStream) { let value = match self { - Alignment::On => format_ident!("On"), - Alignment::Off => format_ident!("Off"), + Self::On => format_ident!("On"), + Self::Off => format_ident!("Off"), }; let quoted = quote! { ::pgrx::pgrx_sql_entity_graph::Alignment::#value From 718c1314af4ab52f14ac9deeb5793072816139fd Mon Sep 17 00:00:00 2001 From: adamnemecek Date: Tue, 28 Apr 2026 01:00:04 -0700 Subject: [PATCH 2/2] ran `cargo fmt` --- cargo-pgrx/src/command/bench.rs | 7 +++---- cargo-pgrx/src/command/regress.rs | 19 ++++++++++--------- cargo-pgrx/src/command/run.rs | 8 +++++--- cargo-pgrx/src/command/test.rs | 9 ++++++--- pgrx-macros/src/rewriter.rs | 3 +-- pgrx-pg-config/src/lib.rs | 12 +++--------- .../src/extension_sql/entity.rs | 8 ++------ .../src/extension_sql/mod.rs | 4 +--- pgrx-sql-entity-graph/src/extern_args.rs | 4 +--- 9 files changed, 32 insertions(+), 42 deletions(-) diff --git a/cargo-pgrx/src/command/bench.rs b/cargo-pgrx/src/command/bench.rs index d2df40a756..f93a7ad5b2 100644 --- a/cargo-pgrx/src/command/bench.rs +++ b/cargo-pgrx/src/command/bench.rs @@ -261,10 +261,9 @@ impl CommandExecute for Bench { baseline.as_ref(), compare_group.as_ref().map(|group| group.group_name.as_str()), )); - if show_human_output - && let Some(completed_benchmark) = summary_benchmarks.last() { - print_completed_benchmark(completed_benchmark); - } + if show_human_output && let Some(completed_benchmark) = summary_benchmarks.last() { + print_completed_benchmark(completed_benchmark); + } } let status = if failures == 0 { diff --git a/cargo-pgrx/src/command/regress.rs b/cargo-pgrx/src/command/regress.rs index 6e8ed72ad2..1824587da8 100644 --- a/cargo-pgrx/src/command/regress.rs +++ b/cargo-pgrx/src/command/regress.rs @@ -436,8 +436,7 @@ impl CommandExecute for Regress { // When the user explicitly filters, error if any matched test // has no expected output (they should use --add first) - let output_names = - output_files.iter().map(make_test_name).collect::>(); + let output_names = output_files.iter().map(make_test_name).collect::>(); for entry in &test_files { let name = make_test_name(entry); if !output_names.contains(&name) { @@ -640,9 +639,10 @@ impl Regress { for entry in &test_files { let name = make_test_name(entry); if let Some(ref filter) = self.test_filter - && !name.contains(filter) { - continue; - } + && !name.contains(filter) + { + continue; + } if output_names.contains(&name) { ready.push(name); } else { @@ -837,10 +837,11 @@ fn print_regression_diffs(manifest_path: &Path, verbose: u8, run: u32, repeat: u } if verbose >= 1 - && let Ok(content) = std::fs::read_to_string(&diffs_path) { - eprintln!(); - eprintln!("{content}"); - } + && let Ok(content) = std::fs::read_to_string(&diffs_path) + { + eprintln!(); + eprintln!("{content}"); + } // When repeating, rename to regression..diffs so each run's output is preserved let final_path = if repeat > 1 { diff --git a/cargo-pgrx/src/command/run.rs b/cargo-pgrx/src/command/run.rs index d756962f07..393d5bc46d 100644 --- a/cargo-pgrx/src/command/run.rs +++ b/cargo-pgrx/src/command/run.rs @@ -88,9 +88,11 @@ impl Run { // If the first positional arg isn't a recognized PG version (pgXX) // and no dbname was given, treat it as a dbname if let Some(ref v) = self.pg_version - && !pgrx.is_feature_flag(v) && self.dbname.is_none() { - self.dbname = self.pg_version.take(); - } + && !pgrx.is_feature_flag(v) + && self.dbname.is_none() + { + self.dbname = self.pg_version.take(); + } let (package_manifest, package_manifest_path) = get_package_manifest( &self.features, diff --git a/cargo-pgrx/src/command/test.rs b/cargo-pgrx/src/command/test.rs index 36732952f1..b278004877 100644 --- a/cargo-pgrx/src/command/test.rs +++ b/cargo-pgrx/src/command/test.rs @@ -97,9 +97,12 @@ impl CommandExecute for Test { // If the first positional arg isn't a recognized PG version (pgXX or "all") // and no testname was given, treat it as a testname filter if let Some(ref v) = self.pg_version - && v != "all" && !pgrx.is_feature_flag(v) && self.testname.is_none() { - self.testname = self.pg_version.take(); - } + && v != "all" + && !pgrx.is_feature_flag(v) + && self.testname.is_none() + { + self.testname = self.pg_version.take(); + } if self.pg_version.as_deref() == Some("all") { // run the tests for **all** the Postgres versions we know about diff --git a/pgrx-macros/src/rewriter.rs b/pgrx-macros/src/rewriter.rs index 04aa2b35da..6a16d41f77 100644 --- a/pgrx-macros/src/rewriter.rs +++ b/pgrx-macros/src/rewriter.rs @@ -55,8 +55,7 @@ pub fn item_fn_without_rewrite( let generics = func.sig.generics.clone(); // looking for this pattern: #[pg_guard(unsafe_entry_thread)] - let unsafe_entry_thread = - attr.into_iter().any(|tt| tt.to_string() == "unsafe_entry_thread"); + let unsafe_entry_thread = attr.into_iter().any(|tt| tt.to_string() == "unsafe_entry_thread"); if sig.abi.clone().and_then(|abi| abi.name).is_none_or(|name| name.value() != "C-unwind") { panic!("#[pg_guard] must be combined with extern \"C-unwind\""); diff --git a/pgrx-pg-config/src/lib.rs b/pgrx-pg-config/src/lib.rs index ce915abfaf..1eb22429e0 100644 --- a/pgrx-pg-config/src/lib.rs +++ b/pgrx-pg-config/src/lib.rs @@ -88,9 +88,7 @@ impl PgMinorVersion { fn version(&self) -> Option { match self { Self::Latest => None, - Self::Release(v) | Self::Beta(v) | Self::Rc(v) => { - Some(*v) - } + Self::Release(v) | Self::Beta(v) | Self::Rc(v) => Some(*v), } } } @@ -579,12 +577,8 @@ pub enum PgrxHomeError { impl From for std::io::Error { fn from(value: PgrxHomeError) -> Self { match value { - PgrxHomeError::NoHomeDirectory => { - Self::new(ErrorKind::NotFound, value.to_string()) - } - PgrxHomeError::MissingPgrxHome(_) => { - Self::new(ErrorKind::NotFound, value.to_string()) - } + PgrxHomeError::NoHomeDirectory => Self::new(ErrorKind::NotFound, value.to_string()), + PgrxHomeError::MissingPgrxHome(_) => Self::new(ErrorKind::NotFound, value.to_string()), PgrxHomeError::IoError(e) => e, } } diff --git a/pgrx-sql-entity-graph/src/extension_sql/entity.rs b/pgrx-sql-entity-graph/src/extension_sql/entity.rs index a880090889..fc4baee5ae 100644 --- a/pgrx-sql-entity-graph/src/extension_sql/entity.rs +++ b/pgrx-sql-entity-graph/src/extension_sql/entity.rs @@ -224,9 +224,7 @@ impl SqlDeclaredEntity { pub fn type_ident(&self) -> Option<&str> { match self { - Self::Type(data) | Self::Enum(data) => { - Some(data.type_ident.as_str()) - } + Self::Type(data) | Self::Enum(data) => Some(data.type_ident.as_str()), Self::Function(_) => None, } } @@ -244,9 +242,7 @@ impl SqlDeclaredEntity { } false } - (SqlDeclared::Function(ident_name), &Self::Function(data)) => { - ident_name == &data.name - } + (SqlDeclared::Function(ident_name), &Self::Function(data)) => ident_name == &data.name, _ => false, } } diff --git a/pgrx-sql-entity-graph/src/extension_sql/mod.rs b/pgrx-sql-entity-graph/src/extension_sql/mod.rs index 37368c3a2c..f464b6026f 100644 --- a/pgrx-sql-entity-graph/src/extension_sql/mod.rs +++ b/pgrx-sql-entity-graph/src/extension_sql/mod.rs @@ -371,9 +371,7 @@ impl ToRustCodeTokens for SqlDeclared {} impl SqlDeclared { fn section_identifier_tokens(&self) -> TokenStream2 { let identifier = match self { - Self::Type(value) | Self::Enum(value) | Self::Function(value) => { - value - } + Self::Type(value) | Self::Enum(value) | Self::Function(value) => value, }; let identifier_split = identifier.split("::").collect::>(); if identifier_split.len() == 1 { diff --git a/pgrx-sql-entity-graph/src/extern_args.rs b/pgrx-sql-entity-graph/src/extern_args.rs index b589e63c0b..8a7e6f222a 100644 --- a/pgrx-sql-entity-graph/src/extern_args.rs +++ b/pgrx-sql-entity-graph/src/extern_args.rs @@ -201,9 +201,7 @@ impl ToTokens for ExternArgs { Self::Support(item) => tokens.append_all(quote! { Support(#item) }), Self::Name(_s) => tokens.append_all(quote! { Name(String::from("#_s")) }), Self::Cost(_s) => tokens.append_all(quote! { Cost(String::from("#_s")) }), - Self::Requires(items) => { - tokens.append_all(quote! { Requires(vec![#(#items),*]) }) - } + Self::Requires(items) => tokens.append_all(quote! { Requires(vec![#(#items),*]) }), } } }