Remove archeology comments.

Author: mbutrovich

native/core/src/execution/operators/schema_align.rs

@@ -16,11 +16,11 @@
 // under the License.
 
 //! `SchemaAlignExec` reshapes its child's output so the per-column Arrow type and field-level
-//! nullability match what Spark catalyst declared. Used between an inlined native subtree and
-//! `ShuffleWriterExec` when the FFI deep-copy + `ScanExec` cast in `build_record_batch` are both
-//! gone, so DataFusion / `datafusion-spark` return-type drift would otherwise be written into
-//! shuffle blocks. See <https://github.com/apache/datafusion-comet/issues/4515> for the running
-//! list of mismatched functions.
+//! nullability match what Spark catalyst declared, casting where necessary. Sits between a native
+//! subtree and `ShuffleWriterExec` so DataFusion / `datafusion-spark` return-type drift is caught
+//! before it reaches shuffle blocks. See
+//! <https://github.com/apache/datafusion-comet/issues/4515> for the running list of mismatched
+//! functions.
 
 use arrow::array::{ArrayRef, RecordBatch, RecordBatchOptions};
 use arrow::compute::{cast_with_options, CastOptions};
@@ -53,6 +53,9 @@ fn warn_dedup() -> &'static Mutex<HashSet<String>> {
     SET.get_or_init(|| Mutex::new(HashSet::new()))
 }
 
+/// Casts each column of `child`'s output to the data_type Spark catalyst declared, widening
+/// nullability to `actual.nullable || expected.nullable`. See
+/// <https://github.com/apache/datafusion-comet/issues/4515>.
 #[derive(Debug)]
 pub struct SchemaAlignExec {
     child: Arc<dyn ExecutionPlan>,
@@ -74,8 +77,7 @@ impl SchemaAlignExec {
     /// Build a SchemaAlignExec that aligns `child`'s output to `expected`. Returns
     /// `Ok(child)` unchanged when no per-column reshape is needed; otherwise wraps `child`
     /// in a SchemaAlignExec whose target schema preserves `expected`'s data_type and metadata
-    /// but widens nullability to `actual.nullable || expected.nullable` (matching the
-    /// reconciliation rule used at the FFI boundary on `main`).
+    /// but widens nullability to `actual.nullable || expected.nullable`.
     pub fn try_new_or_passthrough(
         child: Arc<dyn ExecutionPlan>,
         expected: &SchemaRef,

native/core/src/execution/planner.rs

@@ -1164,9 +1164,6 @@ impl PhysicalPlanner {
                     )?,
                 );
 
-                // HashAggregate emits its natural shape (group keys + agg results); any
-                // post-aggregate projection is serialized as an explicit `OpStruct::Projection`
-                // op above by the JVM serializer (see `CometBaseAggregate.doConvert`)
                 Ok((
                     scans,
                     shuffle_scans,

spark/src/main/scala/org/apache/spark/sql/comet/execution/shuffle/CometShuffleExchangeExec.scala

@@ -124,7 +124,7 @@ case class CometShuffleExchangeExec(
           ctx.shuffleScanIndices)
       case None =>
         // Non-native child (e.g. CometSparkToColumnarExec): no subtree to inline. The dep gets
-        // built via the legacy convenience overload below; we just need a real RDD of batches.
+        // built via the convenience overload below; we just need a real RDD of batches.
         child.executeColumnar()
     }
   } else if (shuffleType == CometColumnarShuffle) {
@@ -676,9 +676,8 @@ object CometShuffleExchangeExec
    * Implemented as a thin wrapper around [[prepareNativeShuffleDependency]]: synthesizes a
    * `Scan("ShuffleWriterInput")` as the child native op (so the writer's plan is still
    * `ShuffleWriter -> Scan`, consuming JVM batches via Arrow C Stream), wraps `rdd` as the single
-   * leaf input of a thin scheduling RDD, and supplies a minimal [[NativeExecContext]]. Same wire
-   * shape as before; one writer code path for both this case and the [[CometShuffleExchangeExec]]
-   * case.
+   * leaf input of a thin scheduling RDD, and supplies a minimal [[NativeExecContext]]. Lets the
+   * writer use one code path for both this case and the [[CometShuffleExchangeExec]] case.
    */
   def prepareShuffleDependency(
       rdd: RDD[ColumnarBatch],