Make AST hash order-independent (opt-in) (#275)

No sorting needed in minfication, as ast_hash used in minification algo
uses order-independent mode.

It should speed up the minification phase.

---------

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Author: kamilkisiela

lib/query-planner/src/ast/hash.rs

@@ -8,22 +8,22 @@ use crate::ast::selection_set::{FieldSelection, InlineFragmentSelection, Selecti
 use crate::ast::value::Value;
 use crate::state::supergraph_state::{self, OperationKind, TypeNode};
 
-/// Order-dependent hashing
+/// A trait for hashing AST nodes, with support for both order-dependent and order-independent hashing.
 pub trait ASTHash {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H);
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H);
 }
 
 pub fn ast_hash(query: &OperationDefinition) -> u64 {
     let mut hasher = FxHasher::default();
-    query.ast_hash(&mut hasher);
+    query.ast_hash::<_, false>(&mut hasher);
     hasher.finish()
 }
 // In all ShapeHash implementations, we never include anything to do with
 // the position of the element in the query, i.e., fields that involve
 // `Pos`
 
 impl ASTHash for &OperationKind {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
         match self {
             OperationKind::Query => "Query".hash(hasher),
             OperationKind::Mutation => "Mutation".hash(hasher),
@@ -33,55 +33,72 @@ impl ASTHash for &OperationKind {
 }
 
 impl ASTHash for OperationDefinition {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
         self.operation_kind
             .as_ref()
             .or(Some(&supergraph_state::OperationKind::Query))
-            .ast_hash(hasher);
+            .ast_hash::<_, ORDER_INDEPENDENT>(hasher);
 
-        self.selection_set.ast_hash(hasher);
-        self.variable_definitions.ast_hash(hasher);
+        self.selection_set.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
+        self.variable_definitions
+            .ast_hash::<_, ORDER_INDEPENDENT>(hasher);
     }
 }
 
 impl<T: ASTHash> ASTHash for Option<T> {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
         match self {
             None => false.hash(hasher),
             Some(t) => {
                 Some(true).hash(hasher);
-                t.ast_hash(hasher);
+                t.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
             }
         }
     }
 }
 
 impl ASTHash for SelectionSet {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
-        for item in &self.items {
-            item.ast_hash(hasher);
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
+        if ORDER_INDEPENDENT {
+            let mut combined_hash: u64 = 0;
+            let build_hasher = FxBuildHasher;
+
+            // To achieve an order-independent hash, we hash each key-value pair
+            // individually and then combine their hashes using XOR (^).
+            // Since XOR is commutative, the final hash is not affected by the iteration order.
+            for item in &self.items {
+                let mut key_val_hasher = build_hasher.build_hasher();
+                item.ast_hash::<_, ORDER_INDEPENDENT>(&mut key_val_hasher);
+                combined_hash ^= key_val_hasher.finish();
+            }
+
+            hasher.write_u64(combined_hash);
+        } else {
+            for item in &self.items {
+                item.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
+            }
         }
     }
 }
 
 impl ASTHash for SelectionItem {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
         match self {
-            SelectionItem::Field(field) => field.ast_hash(hasher),
-            SelectionItem::InlineFragment(frag) => frag.ast_hash(hasher),
+            SelectionItem::Field(field) => field.ast_hash::<_, ORDER_INDEPENDENT>(hasher),
+            SelectionItem::InlineFragment(frag) => frag.ast_hash::<_, ORDER_INDEPENDENT>(hasher),
             SelectionItem::FragmentSpread(name) => name.hash(hasher),
         }
     }
 }
 
 impl ASTHash for &FieldSelection {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
         self.name.hash(hasher);
         self.alias.hash(hasher);
-        self.selections.ast_hash(hasher);
+        self.selections.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
 
         if let Some(args) = &self.arguments {
-            args.ast_hash(hasher);
+            args.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
         }
 
         if let Some(var_name) = self.include_if.as_ref() {
@@ -96,9 +113,9 @@ impl ASTHash for &FieldSelection {
 }
 
 impl ASTHash for &InlineFragmentSelection {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
         self.type_condition.hash(hasher);
-        self.selections.ast_hash(hasher);
+        self.selections.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
         if let Some(var_name) = self.include_if.as_ref() {
             "@include".hash(hasher);
             var_name.hash(hasher);
@@ -111,7 +128,7 @@ impl ASTHash for &InlineFragmentSelection {
 }
 
 impl ASTHash for ArgumentsMap {
-    fn ast_hash<H: Hasher>(&self, state: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, state: &mut H) {
         let mut combined_hash: u64 = 0;
         let build_hasher = FxBuildHasher;
 
@@ -121,7 +138,7 @@ impl ASTHash for ArgumentsMap {
         for (key, value) in self.into_iter() {
             let mut key_val_hasher = build_hasher.build_hasher();
             key.hash(&mut key_val_hasher);
-            value.ast_hash(&mut key_val_hasher);
+            value.ast_hash::<_, ORDER_INDEPENDENT>(&mut key_val_hasher);
             combined_hash ^= key_val_hasher.finish();
         }
 
@@ -130,15 +147,15 @@ impl ASTHash for ArgumentsMap {
 }
 
 impl ASTHash for Vec<VariableDefinition> {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
         let mut combined_hash: u64 = 0;
         let build_hasher = FxBuildHasher;
         // To achieve an order-independent hash, we hash each key-value pair
         // individually and then combine their hashes using XOR (^).
         // Since XOR is commutative, the final hash is not affected by the iteration order.
         for variable in self.iter() {
             let mut local_hasher = build_hasher.build_hasher();
-            variable.ast_hash(&mut local_hasher);
+            variable.ast_hash::<_, ORDER_INDEPENDENT>(&mut local_hasher);
             combined_hash ^= local_hasher.finish();
         }
 
@@ -147,41 +164,41 @@ impl ASTHash for Vec<VariableDefinition> {
 }
 
 impl ASTHash for VariableDefinition {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
         self.name.hash(hasher);
-        self.variable_type.ast_hash(hasher);
-        self.default_value.ast_hash(hasher);
+        self.variable_type.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
+        self.default_value.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
     }
 }
 
 impl ASTHash for TypeNode {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
         match self {
             TypeNode::Named(name) => name.hash(hasher),
             TypeNode::List(inner) => {
                 "list".hash(hasher);
-                inner.ast_hash(hasher);
+                inner.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
             }
             TypeNode::NonNull(inner) => {
                 "non_null".hash(hasher);
-                inner.ast_hash(hasher);
+                inner.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
             }
         }
     }
 }
 
 impl ASTHash for Value {
-    fn ast_hash<H: Hasher>(&self, hasher: &mut H) {
+    fn ast_hash<H: Hasher, const ORDER_INDEPENDENT: bool>(&self, hasher: &mut H) {
         match self {
             Value::List(values) => {
                 for value in values {
-                    value.ast_hash(hasher);
+                    value.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
                 }
             }
             Value::Object(map) => {
                 for (name, value) in map {
                     name.hash(hasher);
-                    value.ast_hash(hasher);
+                    value.ast_hash::<_, ORDER_INDEPENDENT>(hasher);
                 }
             }
             Value::Null => {
@@ -310,10 +327,10 @@ mod tests {
         args2.add_argument("a".to_string(), Value::Int(1));
 
         let mut hasher1 = FxHasher::default();
-        args1.ast_hash(&mut hasher1);
+        args1.ast_hash::<_, true>(&mut hasher1);
 
         let mut hasher2 = FxHasher::default();
-        args2.ast_hash(&mut hasher2);
+        args2.ast_hash::<_, true>(&mut hasher2);
 
         assert_eq!(
             hasher1.finish(),
@@ -351,10 +368,10 @@ mod tests {
         ];
 
         let mut hasher1 = FxHasher::default();
-        vars1.ast_hash(&mut hasher1);
+        vars1.ast_hash::<_, true>(&mut hasher1);
 
         let mut hasher2 = FxHasher::default();
-        vars2.ast_hash(&mut hasher2);
+        vars2.ast_hash::<_, true>(&mut hasher2);
 
         assert_eq!(
             hasher1.finish(),

lib/query-planner/src/ast/minification/mod.rs

@@ -1,21 +1,18 @@
 use crate::ast::document::Document;
-use crate::ast::minification::sort::sort_operation;
 use crate::ast::minification::stats::Stats;
 use crate::ast::minification::transform::transform_operation;
 use crate::ast::{minification::error::MinificationError, operation::OperationDefinition};
 use crate::state::supergraph_state::{OperationKind, SupergraphState};
 
 pub mod error;
 mod selection_id;
-mod sort;
 mod stats;
 mod transform;
 
 pub fn minify_operation(
     operation: OperationDefinition,
     supergraph: &SupergraphState,
 ) -> Result<Document, MinificationError> {
-    let operation = sort_operation(operation);
     let root_type_name = get_root_type_name(&operation, supergraph)?.to_string();
     let stats = Stats::from_operation(&operation.selection_set, supergraph, &root_type_name)?;
     transform_operation(supergraph, stats, &root_type_name, operation)
@@ -265,24 +262,24 @@ mod tests {
             @r"
         query($id: ID!) {
           product(id: $id) {
+            id
+            name
             distributor {
               ...a
             }
-            id
-            name
             ... on Book {
               relatedProducts {
+                id
+                name
                 distributor {
                   ...a
                 }
-                id
-                name
                 ... on Book {
                   relatedProducts {
+                    id
                     distributor {
                       ...c
                     }
-                    id
                   }
                 }
               }
@@ -298,22 +295,22 @@ mod tests {
         fragment a on BusinessEntity {
           id
           name
-          ... on Manufacturer {
-            ...b
-          }
           ... on Supplier {
-            __typename
             licenseNumber
+            __typename
           }
           ... on Vendor {
-            __typename
             preferred
+            __typename
+          }
+          ... on Manufacturer {
+            ...b
           }
         }
 
         fragment b on Manufacturer {
-          __typename
           country
+          __typename
         }
 
         fragment c on BusinessEntity {

lib/query-planner/src/ast/minification/selection_id.rs

@@ -9,6 +9,6 @@ pub type SelectionId = u64;
 pub fn generate_selection_id(type_name: &str, selection_set: &SelectionSet) -> SelectionId {
     let mut hasher = DefaultHasher::new();
     type_name.hash(&mut hasher);
-    selection_set.ast_hash(&mut hasher);
+    selection_set.ast_hash::<_, true>(&mut hasher);
     hasher.finish()
 }