fix(ci): restore rule-name error context in analysis phase, fix broken doc links, format Cargo.toml

Author: notfilippo

datafusion/optimizer/Cargo.toml

@@ -53,6 +53,7 @@ recursive_protection = ["dep:recursive"]
 # traits).
 [dependencies]
 arrow = { workspace = true }
+async-trait = { workspace = true }
 chrono = { workspace = true }
 datafusion-common = { workspace = true, default-features = true }
 datafusion-expr = { workspace = true }
@@ -61,7 +62,6 @@ datafusion-physical-expr = { workspace = true }
 indexmap = { workspace = true }
 itertools = { workspace = true }
 log = { workspace = true }
-async-trait = { workspace = true }
 recursive = { workspace = true, optional = true }
 regex = { workspace = true }
 regex-syntax = "0.8.9"

datafusion/optimizer/src/logical_pipeline/mod.rs

@@ -16,7 +16,7 @@
 // under the License.
 
 //! [`LogicalPlanningPipeline`]: an ordered sequence of named [`Phase`]s that
-//! transform a [`LogicalPlan`] before physical planning.
+//! transform a `LogicalPlan` before physical planning.
 //!
 //! Inspired by Spark SQL's `Batch(name, strategy, rules)` model.
 
@@ -55,12 +55,10 @@ pub enum Strategy {
     /// Apply each rule exactly once. No convergence check is performed.
     Once,
     /// Repeat until the plan stops changing or `max_passes` iterations are
-    /// reached. Convergence is detected via [`LogicalPlanSignature`] so the
+    /// reached. Convergence is detected via a plan signature hash so the
     /// loop exits early as soon as a full pass produces no change.
     ///
     /// `max_passes: None` defers to `config.optimizer.max_passes` at runtime.
-    ///
-    /// [`LogicalPlanSignature`]: crate::plan_signature::LogicalPlanSignature
     FixedPoint { max_passes: Option<usize> },
 }
 

datafusion/optimizer/src/logical_pipeline/sync_phase.rs

@@ -152,10 +152,14 @@ impl SyncAnalysisPhase {
 
         'outer: for _ in 0..passes {
             if let Some(rule) = &fn_rewrite_rule {
-                plan = rule.analyze(plan, config)?;
+                plan = rule
+                    .analyze(plan, config)
+                    .map_err(|e| e.context(rule.name()))?;
             }
             for rule in &self.rules {
-                plan = rule.analyze(plan, config)?;
+                plan = rule
+                    .analyze(plan, config)
+                    .map_err(|e| e.context(rule.name()))?;
             }
             if !previous_plans.insert(LogicalPlanSignature::new(&plan)) {
                 break 'outer;
@@ -202,11 +206,15 @@ impl SyncAnalysisPhase {
 
         'outer: for _ in 0..passes {
             if let Some(rule) = &fn_rewrite_rule {
-                plan = rule.analyze(plan, config)?;
+                plan = rule
+                    .analyze(plan, config)
+                    .map_err(|e| e.context(rule.name()))?;
                 observer(&plan, rule.name());
             }
             for rule in &self.rules {
-                plan = rule.analyze(plan, config)?;
+                plan = rule
+                    .analyze(plan, config)
+                    .map_err(|e| e.context(rule.name()))?;
                 observer(&plan, rule.name());
             }
             if !previous_plans.insert(LogicalPlanSignature::new(&plan)) {
@@ -224,7 +232,7 @@ impl SyncAnalysisPhase {
 impl SyncPhase<dyn OptimizerRule + Send + Sync> {
     /// Apply all optimization rules in order, respecting [`ApplyOrder`] recursion.
     ///
-    /// Uses [`LogicalPlanSignature`] to detect fixpoint convergence early.
+    /// Uses a plan signature hash to detect fixpoint convergence early.
     /// Checks plan invariants before the first pass and schema invariants after
     /// each rule.
     pub fn apply(