Remove unnecessary parentheses

jjaderberg · jjaderberg · commit 968c6b7f4229 · 2025-10-10T17:53:30.000+02:00
diff --git a/algo-common/src/main/java/org/neo4j/gds/Converters.java b/algo-common/src/main/java/org/neo4j/gds/Converters.java
@@ -39,11 +39,11 @@ static RelationshipConsumer longToIntConsumer(IntBinaryPredicate p) {
     }
 
     static RelationshipWithPropertyConsumer longToIntConsumer(IntIntDoublePredicate p) {
-        return ((sourceNodeId, targetNodeId, property) -> {
+        return (sourceNodeId, targetNodeId, property) -> {
             int s = Math.toIntExact(sourceNodeId);
             int t = Math.toIntExact(targetNodeId);
             return p.test(s, t, property);
-        });
+        };
     }
 
     @FunctionalInterface
diff --git a/algo/src/main/java/org/neo4j/gds/bridges/Bridges.java b/algo/src/main/java/org/neo4j/gds/bridges/Bridges.java
@@ -73,7 +73,7 @@ public BridgeResult compute() {
         //each edge may have at most one event to the stack at the same time
         var stack = HugeObjectArray.newArray(StackEvent.class, graph.relationshipCount());
 
-        BiConsumer<Long,Long> onLastChildVisit = (treeSizeTracker.isPresent()) ? treeSizeTracker.get()::recordTreeChild : (a,b)->{};
+        BiConsumer<Long,Long> onLastChildVisit = treeSizeTracker.isPresent() ? treeSizeTracker.get()::recordTreeChild : (a,b)->{};
         int listIndex=0;
         var n = graph.nodeCount();
         for (long i = 0; i < n; ++i) {
diff --git a/algo/src/main/java/org/neo4j/gds/bridges/BridgesMemoryEstimateDefinition.java b/algo/src/main/java/org/neo4j/gds/bridges/BridgesMemoryEstimateDefinition.java
@@ -52,14 +52,14 @@ public MemoryEstimation memoryEstimation() {
                     .perNode("treeSize", HugeLongArray::memoryEstimation)
                      .build());
         }
-        builder.rangePerGraphDimension("stack", ((graphDimensions, concurrency) -> {
+        builder.rangePerGraphDimension("stack", (graphDimensions, concurrency) -> {
             long relationshipCount = graphDimensions.relCountUpperBound();
             return MemoryRange.of(
                 HugeObjectArray.memoryEstimation(relationshipCount, Estimate.sizeOfInstance(Bridges.StackEvent.class))
             );
 
 
-        }));
+        });
 
         return builder.build();
     }
diff --git a/algo/src/main/java/org/neo4j/gds/cliqueCounting/CliqueCountingMemoryEstimateDefinition.java b/algo/src/main/java/org/neo4j/gds/cliqueCounting/CliqueCountingMemoryEstimateDefinition.java
@@ -42,13 +42,13 @@ public MemoryEstimation memoryEstimation() {
 
     private MemoryEstimation thread(){
             return MemoryEstimations.builder()
-                .rangePerGraphDimension("Intersections",((graphDimensions, concurrency) -> {
+                .rangePerGraphDimension("Intersections", (graphDimensions, concurrency) -> {
                     var  bound1 = (long)(graphDimensions.averageDegree()*2.7);
                     var bound2  = (long) (0.48*Math.sqrt(graphDimensions.relCountUpperBound())); //a theoretical bound  ¯\_(ツ)_/¯
                     var cost1 = cost(bound1);
                     var cost2 = cost(bound2);
                     return MemoryRange.of(Math.min(cost1, cost2), Math.max(cost1, cost2));
-                }))
+                })
                 .build();
 
     }
diff --git a/algo/src/main/java/org/neo4j/gds/indexInverse/InverseRelationshipsMemoryEstimateDefinition.java b/algo/src/main/java/org/neo4j/gds/indexInverse/InverseRelationshipsMemoryEstimateDefinition.java
@@ -50,14 +50,14 @@ public MemoryEstimation memoryEstimation() {
                     AdjacencyListBehavior.adjacencyListsFromStarEstimation(false)
                 );
 
-                builderForType.perGraphDimension("All properties", ((graphDimensions, concurrency) -> {
+                builderForType.perGraphDimension("All properties", (graphDimensions, concurrency) -> {
                     var singlePropertyEstimation = AdjacencyListBehavior
                         .adjacencyPropertiesFromStarEstimation( false)
                         .estimate(graphDimensions, concurrency)
                         .memoryUsage();
 
                     return singlePropertyEstimation.times(graphDimensions.relationshipPropertyTokens().size());
-                }));
+                });
 
                 builder.add(String.format(Locale.US, "Inverse '%s'", typeName), builderForType.build());
             } else {
@@ -69,14 +69,14 @@ public MemoryEstimation memoryEstimation() {
                 );
 
 
-                builderForType.perGraphDimension("properties", ((graphDimensions, concurrency) -> {
+                builderForType.perGraphDimension("properties", (graphDimensions, concurrency) -> {
                     var singlePropertyEstimation = AdjacencyListBehavior
                         .adjacencyPropertiesEstimation(relationshipType, false)
                         .estimate(graphDimensions, concurrency)
                         .memoryUsage();
 
                     return singlePropertyEstimation.times(graphDimensions.relationshipPropertyTokens().size());
-                }));
+                });
 
                 builder.add(String.format(Locale.US, "Inverse '%s'", typeName), builderForType.build());
             }
diff --git a/algo/src/main/java/org/neo4j/gds/kcore/KCoreDecompositionMemoryEstimateDefinition.java b/algo/src/main/java/org/neo4j/gds/kcore/KCoreDecompositionMemoryEstimateDefinition.java
@@ -36,7 +36,7 @@ public MemoryEstimation memoryEstimation() {
             .perNode("cores", HugeIntArray::memoryEstimation)
             .perThread("KCoreDecompositionTask", KCoreDecompositionTask.memoryEstimation());
 
-        builder.perGraphDimension("RebuildTask", ((graphDimensions, concurrency) -> {
+        builder.perGraphDimension("RebuildTask", (graphDimensions, concurrency) -> {
             var resizedNodeCount = Math.max(
                 1,
                 (long) Math.ceil(graphDimensions.nodeCount() * KCoreDecomposition.REBUILD_CONSTANT)
@@ -46,7 +46,7 @@ public MemoryEstimation memoryEstimation() {
             var rebuildArray = HugeIntArray.memoryEstimation(resizedNodeCount);
             return MemoryRange.of(totalRebuildTasks + rebuildArray);
 
-        }));
+        });
 
         return builder.build();
     }
diff --git a/algo/src/main/java/org/neo4j/gds/pricesteiner/PrizeSteinerTreeMemoryEstimateDefinition.java b/algo/src/main/java/org/neo4j/gds/pricesteiner/PrizeSteinerTreeMemoryEstimateDefinition.java
@@ -56,12 +56,12 @@ private MemoryEstimation  growthSpecificMemory(){
             .add("cluster structure", clusterStructureSpecificMemory())
             .add("edge queue", edgeQueueSpecificMemory())
             .add("cluster queue", clusterQueueSpecificMemory())
-            .rangePerGraphDimension("edge save", ((graphDimensions, concurrency) -> {
+            .rangePerGraphDimension("edge save", (graphDimensions, concurrency) -> {
                 long  edges = graphDimensions.relCountUpperBound();
                 var edgePartsSize = HugeLongArray.memoryEstimation(edges);
                 var edgeWeightsSize=  HugeDoubleArray.memoryEstimation(edges/2);
                 return MemoryRange.of(edgePartsSize +edgeWeightsSize);
-            }))
+            })
             .perNode("tree edges", HugeLongArray::memoryEstimation)
             .build();
     }
diff --git a/algo/src/main/java/org/neo4j/gds/pricesteiner/StrongPruning.java b/algo/src/main/java/org/neo4j/gds/pricesteiner/StrongPruning.java
@@ -117,7 +117,7 @@ void performPruning(){
                 }
                 var actualParentCost = parentCost.getValue();
 
-                if (Double.compare(actualParentCost, (dp.get(nextLeaf))) < 0) {
+                if (Double.compare(actualParentCost, dp.get(nextLeaf)) < 0) {
                     dp.addTo(actualParent, dp.get(nextLeaf) - actualParentCost);
                     parentArray.set(nextLeaf, actualParent);
                     parentCostArray.set(nextLeaf, actualParentCost);
diff --git a/algo/src/main/java/org/neo4j/gds/similarity/filteredknn/ExistingTargetNodeFiltering.java b/algo/src/main/java/org/neo4j/gds/similarity/filteredknn/ExistingTargetNodeFiltering.java
@@ -89,7 +89,7 @@ static ExistingTargetNodeFiltering create(
             }
         });
 
-        var seededOptimally = (startingSeeds[k] == -1) && (optionalSimilarityFunction.isPresent()); //if there less than `k+1` targets, we optimally find solution just by seeding.
+        var seededOptimally = (startingSeeds[k] == -1) && optionalSimilarityFunction.isPresent(); //if there less than `k+1` targets, we optimally find solution just by seeding.
         return new ExistingTargetNodeFiltering(
             neighbourConsumers,
             new SeedingSummary(nodeCountAdder.longValue(), nodepairAdder.longValue(), seededOptimally)
diff --git a/algo/src/main/java/org/neo4j/gds/similarity/filteredknn/FilteredKnn.java b/algo/src/main/java/org/neo4j/gds/similarity/filteredknn/FilteredKnn.java
@@ -136,7 +136,7 @@ private FilteredKnn(
     @Override
     public FilteredKnnResult compute() {
         var seedingSummary = targetNodeFiltering.seedingSummary();
-        KnnResult result = (seedingSummary.seededOptimally()) ?
+        KnnResult result = seedingSummary.seededOptimally() ?
             new KnnResult(
                 HugeObjectArray.newArray(NeighborList.class, 0),
                 0,
diff --git a/algo/src/main/java/org/neo4j/gds/similarity/knn/NeighborList.java b/algo/src/main/java/org/neo4j/gds/similarity/knn/NeighborList.java
@@ -176,7 +176,7 @@ public long add(long element, double priority, SplittableRandom random, double p
             ) {
                 var upperBound = Math.max(upperBoundIdxExclusive, lowerBoundIdxInclusive + 2);
                 for (int i = lowerBoundIdxInclusive; i < upperBound; i += 2) {
-                    if ((clearCheckedFlag(priorityElementPairs[i + 1])) == element) {
+                    if (clearCheckedFlag(priorityElementPairs[i + 1]) == element) {
                         return NOT_INSERTED;
                     }
                 }
diff --git a/io/csv/src/main/java/org/neo4j/gds/core/io/file/csv/CsvNodeVisitor.java b/io/csv/src/main/java/org/neo4j/gds/core/io/file/csv/CsvNodeVisitor.java
@@ -80,13 +80,13 @@ protected void exportElement() {
             fileAppender.startLine();
             fileAppender.append(id());
             // write properties
-            forEachProperty(((key, value) -> {
+            forEachProperty((key, value) -> {
                 try {
                     fileAppender.appendAny(value);
                 } catch (IOException e) {
                     throw new RuntimeException(e);
                 }
-            }));
+            });
 
             fileAppender.endLine();
         } catch (IOException e) {
@@ -133,7 +133,7 @@ private void writeHeaderFile(String headerFileName) {
             headerAppender.startLine();
             headerAppender.append(ID_COLUMN_NAME);
 
-            forEachPropertyWithType(((key, value, type) -> {
+            forEachPropertyWithType((key, value, type) -> {
                 var propertyHeader = formatWithLocale(
                     "%s:%s",
                     key,
@@ -144,7 +144,7 @@ private void writeHeaderFile(String headerFileName) {
                 } catch (IOException e) {
                     throw new RuntimeException(e);
                 }
-            }));
+            });
 
             headerAppender.endLine();
         } catch (IOException e) {
diff --git a/io/csv/src/main/java/org/neo4j/gds/core/io/file/csv/CsvRelationshipVisitor.java b/io/csv/src/main/java/org/neo4j/gds/core/io/file/csv/CsvRelationshipVisitor.java
@@ -80,14 +80,14 @@ protected void exportElement() {
             fileAppender.append(endNode());
 
             // write properties
-            forEachProperty(((key, value) -> {
+            forEachProperty((key, value) -> {
                 try {
                     fileAppender.appendAny(value);
                 } catch (IOException e) {
                     throw new RuntimeException(e);
                 }
 
-            }));
+            });
 
             fileAppender.endLine();
         } catch (IOException e) {
@@ -127,7 +127,7 @@ private void writeHeaderFile(String headerFileName) {
             headerAppender.append(START_ID_COLUMN_NAME);
             headerAppender.append(END_ID_COLUMN_NAME);
 
-            forEachPropertyWithType(((key, value, type) -> {
+            forEachPropertyWithType((key, value, type) -> {
                 var propertyHeader = formatWithLocale(
                     "%s:%s",
                     key,
@@ -138,7 +138,7 @@ private void writeHeaderFile(String headerFileName) {
                 } catch (IOException e) {
                     throw new RuntimeException(e);
                 }
-            }));
+            });
 
             headerAppender.endLine();
         } catch (IOException e) {
diff --git a/legacy-cypher-projection/src/main/java/org/neo4j/gds/legacycypherprojection/NodeSubscriber.java b/legacy-cypher-projection/src/main/java/org/neo4j/gds/legacycypherprojection/NodeSubscriber.java
@@ -106,7 +106,7 @@ public void onField(int offset, AnyValue value)  {
                 maxNeoId = neoId;
             }
         } else if (offset == labelOffset) {
-            if (!(value.isSequenceValue())) {
+            if (!value.isSequenceValue()) {
                 //throwing here will abort execution and error will appear in onError
                 throw new IllegalArgumentException(formatWithLocale(
                     "Type of column `%s` should be of type List, but was `%s`",
diff --git a/ml/ml-core/src/main/java/org/neo4j/gds/ml/core/ComputationContext.java b/ml/ml-core/src/main/java/org/neo4j/gds/ml/core/ComputationContext.java
@@ -68,7 +68,7 @@ public <T extends Tensor<T>> T gradient(Variable<T> variable) {
     }
 
     public void backward(Variable<?> function) {
-        assert (Dimensions.isScalar(function.dimensions())) : "Root variable must be scalar.";
+        assert Dimensions.isScalar(function.dimensions()) : "Root variable must be scalar.";
         assert function.requireGradient() : "Root variable must have requireGradient==true";
 
         gradients.clear();

Original file line number	Diff line number	Diff line change
`@@ -39,11 +39,11 @@ static RelationshipConsumer longToIntConsumer(IntBinaryPredicate p) {`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`static RelationshipWithPropertyConsumer longToIntConsumer(IntIntDoublePredicate p) {`
`42`		`- return ((sourceNodeId, targetNodeId, property) -> {`
	`42`	`+ return (sourceNodeId, targetNodeId, property) -> {`
`43`	`43`	`int s = Math.toIntExact(sourceNodeId);`
`44`	`44`	`int t = Math.toIntExact(targetNodeId);`
`45`	`45`	`return p.test(s, t, property);`
`46`		`- });`
	`46`	`+ };`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`@FunctionalInterface`
Original file line number	Diff line number	Diff line change
`@@ -52,14 +52,14 @@ public MemoryEstimation memoryEstimation() {`
`52`	`52`	`.perNode("treeSize", HugeLongArray::memoryEstimation)`
`53`	`53`	`.build());`
`54`	`54`	`}`
`55`		`- builder.rangePerGraphDimension("stack", ((graphDimensions, concurrency) -> {`
	`55`	`+ builder.rangePerGraphDimension("stack", (graphDimensions, concurrency) -> {`
`56`	`56`	`long relationshipCount = graphDimensions.relCountUpperBound();`
`57`	`57`	`return MemoryRange.of(`
`58`	`58`	`HugeObjectArray.memoryEstimation(relationshipCount, Estimate.sizeOfInstance(Bridges.StackEvent.class))`
`59`	`59`	`);`
`60`	`60`
`61`	`61`
`62`		`- }));`
	`62`	`+ });`
`63`	`63`
`64`	`64`	`return builder.build();`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ void performPruning(){`
`117`	`117`	`}`
`118`	`118`	`var actualParentCost = parentCost.getValue();`
`119`	`119`
`120`		`- if (Double.compare(actualParentCost, (dp.get(nextLeaf))) < 0) {`
	`120`	`+ if (Double.compare(actualParentCost, dp.get(nextLeaf)) < 0) {`
`121`	`121`	`dp.addTo(actualParent, dp.get(nextLeaf) - actualParentCost);`
`122`	`122`	`parentArray.set(nextLeaf, actualParent);`
`123`	`123`	`parentCostArray.set(nextLeaf, actualParentCost);`
Original file line number	Diff line number	Diff line change
`@@ -89,7 +89,7 @@ static ExistingTargetNodeFiltering create(`
`89`	`89`	`}`
`90`	`90`	`});`
`91`	`91`
`92`		- var seededOptimally = (startingSeeds[k] == -1) && (optionalSimilarityFunction.isPresent()); //if there less than `k+1` targets, we optimally find solution just by seeding.
	`92`	+ var seededOptimally = (startingSeeds[k] == -1) && optionalSimilarityFunction.isPresent(); //if there less than `k+1` targets, we optimally find solution just by seeding.
`93`	`93`	`return new ExistingTargetNodeFiltering(`
`94`	`94`	`neighbourConsumers,`
`95`	`95`	`new SeedingSummary(nodeCountAdder.longValue(), nodepairAdder.longValue(), seededOptimally)`