Upgrade clang-format from version 15 to 18 (#7359)

DennisOSRM · nyllet · web-flow · commit 5c6e615c6723 · 2026-02-16T17:14:31.000+01:00
* Upgrade clang-format from version 15 to 19

* Change OSRM backend workflow to use Ubuntu 24.04 not 24.10

* Update clang-format version check in format.sh

* Update clang-format version in workflow

* Update clang-format version check from 19 to 18

* Fix formatting

---------

Co-authored-by: martin nylin &lt;martin.nylin@gmail.com&gt;
diff --git a/.github/workflows/osrm-backend.yml b/.github/workflows/osrm-backend.yml
@@ -94,33 +94,33 @@ jobs:
           token: ${{ secrets.GITHUB_TOKEN }}
 
   format-taginfo-docs:
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v4
-      - name: Use Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - name: Enable Node.js cache
-        uses: actions/cache@v4
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
-      - name: Prepare environment
-        run: |
-          npm ci --ignore-scripts
-          clang-format-15 --version
-      - name: Run checks
-        run: |
-          ./scripts/check_taginfo.py taginfo.json profiles/car.lua
-          # Check that code formatting is up to date
-          ./scripts/format.sh && ./scripts/error_on_dirty.sh "Run './scripts/format.sh' locally and commit the changes."
-          node ./scripts/validate_changelog.js
-          # Check that API documentation is up to date with JSDoc comments in node_osrm.cpp
-          npm run docs && ./scripts/error_on_dirty.sh "Run 'npm run docs' locally and commit the changes."
-          npm audit --production
+    - uses: actions/checkout@v4
+    - name: Use Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: 20
+    - name: Enable Node.js cache
+      uses: actions/cache@v4
+      with:
+        path: ~/.npm
+        key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
+        restore-keys: |
+          ${{ runner.os }}-node-
+    - name: Prepare environment
+      run: |
+        npm ci --ignore-scripts
+        clang-format-18 --version
+    - name: Run checks
+      run: |
+        ./scripts/check_taginfo.py taginfo.json profiles/car.lua
+        # Check that code formatting is up to date
+        ./scripts/format.sh && ./scripts/error_on_dirty.sh "Run './scripts/format.sh' locally and commit the changes."
+        node ./scripts/validate_changelog.js
+        # Check that API documentation is up to date with JSDoc comments in node_osrm.cpp
+        npm run docs && ./scripts/error_on_dirty.sh "Run 'npm run docs' locally and commit the changes."
+        npm audit --production
 
   docker-image-matrix:
     strategy:
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -21,6 +21,7 @@
       - FIXED: Fix compilation with gcc >14 in release with LTO. [#7268](https://github.com/Project-OSRM/osrm-backend/issues/7268)
       - ADDED: Conditionally prefix custom CMake targets with `osrm_` when built as subproject, and add ALIAS targets for FetchContent compatibility [#7267](https://github.com/Project-OSRM/osrm-backend/issues/7267)
     - Misc:
+      - CHANGED: Upgrade from clang-format-15 to clang-format-18 [#7249](https://github.com/Project-OSRM/osrm-backend/issues/7249)
       - ADDED: `--output` / `-o` option to osrm-extract for specifying custom output base path [#4930](https://github.com/Project-OSRM/osrm-backend/issues/4930)
       - ADDED: `--list-inputs` option to all OSRM tools to list required/optional input file extensions for deployment scripts [#2865](https://github.com/Project-OSRM/osrm-backend/issues/2865)
       - ADDED: `--max-header-size` to override the (automatically) configured maximum header size for osrm-routed [#7336](https://github.com/Project-OSRM/osrm-backend/pull/7336)
diff --git a/include/contractor/query_edge.hpp b/include/contractor/query_edge.hpp
@@ -15,8 +15,8 @@ struct QueryEdge
     struct EdgeData
     {
         explicit EdgeData()
-            : turn_id(0), shortcut(false), weight{0}, duration(0), forward(false),
-              backward(false), distance{0}
+            : turn_id(0), shortcut(false), weight{0}, duration(0), forward(false), backward(false),
+              distance{0}
         {
         }
 
diff --git a/include/engine/api/base_api.hpp b/include/engine/api/base_api.hpp
@@ -67,9 +67,8 @@ class BaseAPI
             std::transform(candidates.begin(),
                            candidates.end(),
                            seg_hints.begin(),
-                           [this](const auto &phantom) {
-                               return SegmentHint{phantom, facade.GetCheckSum()};
-                           });
+                           [this](const auto &phantom)
+                           { return SegmentHint{phantom, facade.GetCheckSum()}; });
 
             return json::makeWaypoint(
                 snapped_location,
@@ -135,9 +134,8 @@ class BaseAPI
             std::transform(candidates.begin(),
                            candidates.end(),
                            seg_hints.begin(),
-                           [this](const auto &phantom) {
-                               return SegmentHint{phantom, facade.GetCheckSum()};
-                           });
+                           [this](const auto &phantom)
+                           { return SegmentHint{phantom, facade.GetCheckSum()}; });
             Hint hint{std::move(seg_hints)};
             hint_string = builder->CreateString(hint.ToBase64());
         }
diff --git a/include/engine/api/match_parameters.hpp b/include/engine/api/match_parameters.hpp
@@ -78,9 +78,8 @@ struct MatchParameters : public RouteParameters
                     bool tidy_,
                     const std::vector<std::size_t> &waypoints_,
                     Args &&...args_)
-        : RouteParameters{std::forward<Args>(args_)..., waypoints_}, timestamps{std::move(
-                                                                         timestamps_)},
-          gaps(gaps_), tidy(tidy_)
+        : RouteParameters{std::forward<Args>(args_)..., waypoints_},
+          timestamps{std::move(timestamps_)}, gaps(gaps_), tidy(tidy_)
     {
     }
 
diff --git a/include/engine/api/route_parameters.hpp b/include/engine/api/route_parameters.hpp
@@ -141,8 +141,8 @@ struct RouteParameters : public BaseParameters
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
           number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},
           annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},
-          geometries{geometries_}, overview{overview_},
-          continue_straight{continue_straight_}, waypoints{std::move(waypoints_)}
+          geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},
+          waypoints{std::move(waypoints_)}
     {
     }
 
@@ -157,10 +157,10 @@ struct RouteParameters : public BaseParameters
                     std::vector<std::size_t> waypoints_,
                     Args &&...args_)
         : BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},
-          number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_ !=
-                                                                       AnnotationsType::None},
-          annotations_type{annotations_}, geometries{geometries_}, overview{overview_},
-          continue_straight{continue_straight_}, waypoints{std::move(waypoints_)}
+          number_of_alternatives{alternatives_ ? 1u : 0u},
+          annotations{annotations_ != AnnotationsType::None}, annotations_type{annotations_},
+          geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},
+          waypoints{std::move(waypoints_)}
     {
     }
 
diff --git a/include/engine/api/trip_parameters.hpp b/include/engine/api/trip_parameters.hpp
@@ -60,8 +60,8 @@ struct TripParameters : public RouteParameters
                    DestinationType destination_,
                    bool roundtrip_,
                    Args &&...args_)
-        : RouteParameters{std::forward<Args>(args_)...}, source{source_},
-          destination{destination_}, roundtrip{roundtrip_}
+        : RouteParameters{std::forward<Args>(args_)...}, source{source_}, destination{destination_},
+          roundtrip{roundtrip_}
     {
     }
 
diff --git a/include/engine/phantom_node.hpp b/include/engine/phantom_node.hpp
@@ -44,16 +44,15 @@ namespace osrm::engine
 struct PhantomNode
 {
     PhantomNode()
-        : forward_segment_id{SPECIAL_SEGMENTID, false}, reverse_segment_id{SPECIAL_SEGMENTID,
-                                                                           false},
-          forward_weight(INVALID_EDGE_WEIGHT),
+        : forward_segment_id{SPECIAL_SEGMENTID, false},
+          reverse_segment_id{SPECIAL_SEGMENTID, false}, forward_weight(INVALID_EDGE_WEIGHT),
           reverse_weight(INVALID_EDGE_WEIGHT), forward_weight_offset{0}, reverse_weight_offset{0},
           forward_distance(INVALID_EDGE_DISTANCE), reverse_distance(INVALID_EDGE_DISTANCE),
           forward_distance_offset{0}, reverse_distance_offset{0},
           forward_duration(MAXIMAL_EDGE_DURATION), reverse_duration(MAXIMAL_EDGE_DURATION),
           forward_duration_offset{0}, reverse_duration_offset{0},
-          component({INVALID_COMPONENTID, 0}),
-          fwd_segment_position(0), is_valid_forward_source{false}, is_valid_forward_target{false},
+          component({INVALID_COMPONENTID, 0}), fwd_segment_position(0),
+          is_valid_forward_source{false}, is_valid_forward_target{false},
           is_valid_reverse_source{false}, is_valid_reverse_target{false}, bearing(0)
 
     {
diff --git a/include/engine/routing_algorithms/routing_base_mld.hpp b/include/engine/routing_algorithms/routing_base_mld.hpp
@@ -313,7 +313,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
             const auto &cell =
                 cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
             auto destination = cell.GetDestinationNodes().begin();
-            auto distance = [&cell, node = heapNode.node ]() -> auto
+            auto distance = [&cell, node = heapNode.node]() -> auto
             {
                 if constexpr (IS_MAP_MATCHING)
                 {
@@ -325,8 +325,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                     boost::ignore_unused(cell, node);
                     return 0;
                 }
-            }
-            ();
+            }();
             for (auto shortcut_weight : cell.GetOutWeight(heapNode.node))
             {
                 BOOST_ASSERT(destination != cell.GetDestinationNodes().end());
@@ -361,7 +360,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
             const auto &cell =
                 cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));
             auto source = cell.GetSourceNodes().begin();
-            auto distance = [&cell, node = heapNode.node ]() -> auto
+            auto distance = [&cell, node = heapNode.node]() -> auto
             {
                 if constexpr (IS_MAP_MATCHING)
                 {
@@ -373,8 +372,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,
                     boost::ignore_unused(cell, node);
                     return 0;
                 }
-            }
-            ();
+            }();
             for (auto shortcut_weight : cell.GetInWeight(heapNode.node))
             {
                 BOOST_ASSERT(source != cell.GetSourceNodes().end());
diff --git a/include/extractor/edge_based_node_segment.hpp b/include/extractor/edge_based_node_segment.hpp
@@ -18,9 +18,8 @@ namespace osrm::extractor
 struct EdgeBasedNodeSegment
 {
     EdgeBasedNodeSegment()
-        : forward_segment_id{SPECIAL_SEGMENTID, false}, reverse_segment_id{SPECIAL_SEGMENTID,
-                                                                           false},
-          u(SPECIAL_NODEID), v(SPECIAL_NODEID),
+        : forward_segment_id{SPECIAL_SEGMENTID, false},
+          reverse_segment_id{SPECIAL_SEGMENTID, false}, u(SPECIAL_NODEID), v(SPECIAL_NODEID),
           fwd_segment_position(std::numeric_limits<unsigned short>::max() >>
                                1), // >> 1 because we've only got 15 bits
           is_startpoint(false)
diff --git a/include/partitioner/bisection_graph.hpp b/include/partitioner/bisection_graph.hpp
@@ -105,9 +105,7 @@ std::vector<BisectionInputEdge> adaptToBisectionEdge(std::vector<InputEdge> edge
     std::transform(begin(edges),
                    end(edges),
                    std::back_inserter(result),
-                   [](const auto &edge) {
-                       return BisectionInputEdge{edge.source, edge.target};
-                   });
+                   [](const auto &edge) { return BisectionInputEdge{edge.source, edge.target}; });
 
     return result;
 }
diff --git a/include/partitioner/cell_storage.hpp b/include/partitioner/cell_storage.hpp
@@ -187,10 +187,10 @@ template <storage::Ownership Ownership> class CellStorageImpl
                  const NodeID *const all_sources,
                  const NodeID *const all_destinations)
             : num_source_nodes{data.num_source_nodes},
-              num_destination_nodes{data.num_destination_nodes}, weights{all_weights +
-                                                                         data.value_offset},
-              durations{all_durations + data.value_offset}, distances{all_distances +
-                                                                      data.value_offset},
+              num_destination_nodes{data.num_destination_nodes},
+              weights{all_weights + data.value_offset},
+              durations{all_durations + data.value_offset},
+              distances{all_distances + data.value_offset},
               source_boundary{all_sources + data.source_boundary_offset},
               destination_boundary{all_destinations + data.destination_boundary_offset}
         {
@@ -208,8 +208,8 @@ template <storage::Ownership Ownership> class CellStorageImpl
                  const NodeID *const all_destinations)
             : num_source_nodes{data.num_source_nodes},
               num_destination_nodes{data.num_destination_nodes}, weights{nullptr},
-              durations{nullptr}, distances{nullptr}, source_boundary{all_sources +
-                                                                      data.source_boundary_offset},
+              durations{nullptr}, distances{nullptr},
+              source_boundary{all_sources + data.source_boundary_offset},
               destination_boundary{all_destinations + data.destination_boundary_offset}
         {
             BOOST_ASSERT(num_source_nodes == 0 || all_sources != nullptr);
diff --git a/include/partitioner/edge_based_graph_reader.hpp b/include/partitioner/edge_based_graph_reader.hpp
@@ -163,29 +163,29 @@ graphToEdges(const DynamicEdgeBasedGraph &edge_based_graph)
         [](const NodeID lhs, const NodeID rhs) { return std::max(lhs, rhs); });
 
     std::vector<extractor::EdgeBasedEdge> edges(max_turn_id + 1);
-    tbb::parallel_for(
-        range,
-        [&](const auto range)
-        {
-            for (auto node = range.begin(); node < range.end(); ++node)
-            {
-                for (auto edge : edge_based_graph.GetAdjacentEdgeRange(node))
-                {
-                    const auto &data = edge_based_graph.GetEdgeData(edge);
-                    // we only need to save the forward edges, since the read method
-                    // will convert from forward to bi-directional edges again
-                    if (data.forward)
-                    {
-                        auto target = edge_based_graph.GetTarget(edge);
-                        BOOST_ASSERT(data.turn_id <= max_turn_id);
-                        edges[data.turn_id] = extractor::EdgeBasedEdge{node, target, data};
-                        // only save the forward edge
-                        edges[data.turn_id].data.forward = true;
-                        edges[data.turn_id].data.backward = false;
-                    }
-                }
-            }
-        });
+    tbb::parallel_for(range,
+                      [&](const auto range)
+                      {
+                          for (auto node = range.begin(); node < range.end(); ++node)
+                          {
+                              for (auto edge : edge_based_graph.GetAdjacentEdgeRange(node))
+                              {
+                                  const auto &data = edge_based_graph.GetEdgeData(edge);
+                                  // we only need to save the forward edges, since the read method
+                                  // will convert from forward to bi-directional edges again
+                                  if (data.forward)
+                                  {
+                                      auto target = edge_based_graph.GetTarget(edge);
+                                      BOOST_ASSERT(data.turn_id <= max_turn_id);
+                                      edges[data.turn_id] =
+                                          extractor::EdgeBasedEdge{node, target, data};
+                                      // only save the forward edge
+                                      edges[data.turn_id].data.forward = true;
+                                      edges[data.turn_id].data.backward = false;
+                                  }
+                              }
+                          }
+                      });
 
     return edges;
 }
diff --git a/include/server/api/base_parameters_grammar.hpp b/include/server/api/base_parameters_grammar.hpp
@@ -121,12 +121,11 @@ struct BaseParametersGrammar : boost::spirit::qi::grammar<Iterator, Signature>
         unlimited_rule = qi::lit("unlimited")[qi::_val = std::numeric_limits<double>::infinity()];
 
         bearing_rule =
-            (qi::short_ > ',' > qi::short_)[qi::_val = ph::bind(
-                                                [](short bearing, short range) {
-                                                    return osrm::engine::Bearing{bearing, range};
-                                                },
-                                                qi::_1,
-                                                qi::_2)];
+            (qi::short_ > ',' >
+             qi::short_)[qi::_val = ph::bind([](short bearing, short range)
+                                             { return osrm::engine::Bearing{bearing, range}; },
+                                             qi::_1,
+                                             qi::_2)];
 
         location_rule = (double_ > qi::lit(',') >
                          double_)[qi::_val = ph::bind(
diff --git a/include/util/deallocating_vector.hpp b/include/util/deallocating_vector.hpp
@@ -268,9 +268,7 @@ template <typename ElementT> class DeallocatingVector
         ++current_size;
     }
 
-    void reserve(const std::size_t) const
-    { /* don't do anything */
-    }
+    void reserve(const std::size_t) const { /* don't do anything */ }
 
     void resize(const std::size_t new_size)
     {
diff --git a/include/util/debug.hpp b/include/util/debug.hpp
@@ -44,8 +44,7 @@ inline std::ostream &operator<<(std::ostream &out, const RouteStep &step)
     {
         out << "(Lanes: " << static_cast<int>(intersection.lanes.lanes_in_turn) << " "
             << static_cast<int>(intersection.lanes.first_lane_from_the_right) << " ["
-            << intersection.in << "," << intersection.out << "]"
-            << " bearings:";
+            << intersection.in << "," << intersection.out << "]" << " bearings:";
         for (auto bearing : intersection.bearings)
             out << " " << bearing;
         out << ", entry: ";
diff --git a/scripts/format.sh b/scripts/format.sh
@@ -19,18 +19,18 @@ elif [[ ${OS} = "Darwin" ]] ; then
 fi
 
 # Discover clang-format
-if type clang-format-15 2> /dev/null ; then
-    CLANG_FORMAT=clang-format-15
+if type clang-format-18 2> /dev/null ; then
+    CLANG_FORMAT=clang-format-18
 elif type clang-format 2> /dev/null ; then
     # Clang format found, but need to check version
     CLANG_FORMAT=clang-format
     V=$(clang-format --version)
-    if [[ $V != *15.0* ]] ; then
-        echo "clang-format is not 15.0 (returned ${V})"
+    if [[ $V != *18* ]] ; then
+        echo "clang-format is not 18 (returned ${V})"
         #exit 1
     fi
 else
-    echo "No appropriate clang-format found (expected clang-format-15, or clang-format)"
+    echo "No appropriate clang-format found (expected clang-format-18, or clang-format)"
     exit 1
 fi
 
diff --git a/src/benchmarks/static_rtree.cpp b/src/benchmarks/static_rtree.cpp
@@ -43,8 +43,8 @@ void benchmarkQuery(const std::vector<util::Coordinate> &queries,
     TIMER_STOP(query);
 
     std::cout << name << ":\n"
-              << TIMER_MSEC(query) << "ms"
-              << " ->  " << TIMER_MSEC(query) / queries.size() << " ms/query" << std::endl;
+              << TIMER_MSEC(query) << "ms" << " ->  " << TIMER_MSEC(query) / queries.size()
+              << " ms/query" << std::endl;
 }
 
 void benchmark(BenchStaticRTree &rtree, unsigned num_queries)
@@ -71,8 +71,7 @@ int main(int argc, char **argv)
 {
     if (argc < 4)
     {
-        std::cout << "./rtree-bench file.ramIndex file.fileIndx file.nodes"
-                  << "\n";
+        std::cout << "./rtree-bench file.ramIndex file.fileIndx file.nodes" << "\n";
         return 1;
     }
 
diff --git a/src/extractor/edge_based_graph_factory.cpp b/src/extractor/edge_based_graph_factory.cpp
diff --git a/src/extractor/extractor.cpp b/src/extractor/extractor.cpp
diff --git a/src/partitioner/recursive_bisection.cpp b/src/partitioner/recursive_bisection.cpp
diff --git a/src/tools/io-benchmark.cpp b/src/tools/io-benchmark.cpp

Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,8 @@ struct QueryEdge`
`15`	`15`	`struct EdgeData`
`16`	`16`	`{`
`17`	`17`	`explicit EdgeData()`
`18`		`- : turn_id(0), shortcut(false), weight{0}, duration(0), forward(false),`
`19`		`- backward(false), distance{0}`
	`18`	`+ : turn_id(0), shortcut(false), weight{0}, duration(0), forward(false), backward(false),`
	`19`	`+ distance{0}`
`20`	`20`	`{`
`21`	`21`	`}`
`22`	`22`
Original file line number	Diff line number	Diff line change
`@@ -78,9 +78,8 @@ struct MatchParameters : public RouteParameters`
`78`	`78`	`bool tidy_,`
`79`	`79`	`const std::vector<std::size_t> &waypoints_,`
`80`	`80`	`Args &&...args_)`
`81`		`- : RouteParameters{std::forward<Args>(args_)..., waypoints_}, timestamps{std::move(`
`82`		`- timestamps_)},`
`83`		`- gaps(gaps_), tidy(tidy_)`
	`81`	`+ : RouteParameters{std::forward<Args>(args_)..., waypoints_},`
	`82`	`+ timestamps{std::move(timestamps_)}, gaps(gaps_), tidy(tidy_)`
`84`	`83`	`{`
`85`	`84`	`}`
`86`	`85`
Original file line number	Diff line number	Diff line change
`@@ -141,8 +141,8 @@ struct RouteParameters : public BaseParameters`
`141`	`141`	`: BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},`
`142`	`142`	`number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_},`
`143`	`143`	`annotations_type{annotations_ ? AnnotationsType::All : AnnotationsType::None},`
`144`		`- geometries{geometries_}, overview{overview_},`
`145`		`- continue_straight{continue_straight_}, waypoints{std::move(waypoints_)}`
	`144`	`+ geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},`
	`145`	`+ waypoints{std::move(waypoints_)}`
`146`	`146`	`{`
`147`	`147`	`}`
`148`	`148`
`@@ -157,10 +157,10 @@ struct RouteParameters : public BaseParameters`
`157`	`157`	`std::vector<std::size_t> waypoints_,`
`158`	`158`	`Args &&...args_)`
`159`	`159`	`: BaseParameters{std::forward<Args>(args_)...}, steps{steps_}, alternatives{alternatives_},`
`160`		`- number_of_alternatives{alternatives_ ? 1u : 0u}, annotations{annotations_ !=`
`161`		`- AnnotationsType::None},`
`162`		`- annotations_type{annotations_}, geometries{geometries_}, overview{overview_},`
`163`		`- continue_straight{continue_straight_}, waypoints{std::move(waypoints_)}`
	`160`	`+ number_of_alternatives{alternatives_ ? 1u : 0u},`
	`161`	`+ annotations{annotations_ != AnnotationsType::None}, annotations_type{annotations_},`
	`162`	`+ geometries{geometries_}, overview{overview_}, continue_straight{continue_straight_},`
	`163`	`+ waypoints{std::move(waypoints_)}`
`164`	`164`	`{`
`165`	`165`	`}`
`166`	`166`
Original file line number	Diff line number	Diff line change
`@@ -60,8 +60,8 @@ struct TripParameters : public RouteParameters`
`60`	`60`	`DestinationType destination_,`
`61`	`61`	`bool roundtrip_,`
`62`	`62`	`Args &&...args_)`
`63`		`- : RouteParameters{std::forward<Args>(args_)...}, source{source_},`
`64`		`- destination{destination_}, roundtrip{roundtrip_}`
	`63`	`+ : RouteParameters{std::forward<Args>(args_)...}, source{source_}, destination{destination_},`
	`64`	`+ roundtrip{roundtrip_}`
`65`	`65`	`{`
`66`	`66`	`}`
`67`	`67`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,`
`313`	`313`	`const auto &cell =`
`314`	`314`	`cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));`
`315`	`315`	`auto destination = cell.GetDestinationNodes().begin();`
`316`		`- auto distance = [&cell, node = heapNode.node ]() -> auto`
	`316`	`+ auto distance = [&cell, node = heapNode.node]() -> auto`
`317`	`317`	`{`
`318`	`318`	`if constexpr (IS_MAP_MATCHING)`
`319`	`319`	`{`
`@@ -325,8 +325,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,`
`325`	`325`	`boost::ignore_unused(cell, node);`
`326`	`326`	`return 0;`
`327`	`327`	`}`
`328`		`- }`
`329`		`- ();`
	`328`	`+ }();`
`330`	`329`	`for (auto shortcut_weight : cell.GetOutWeight(heapNode.node))`
`331`	`330`	`{`
`332`	`331`	`BOOST_ASSERT(destination != cell.GetDestinationNodes().end());`
`@@ -361,7 +360,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,`
`361`	`360`	`const auto &cell =`
`362`	`361`	`cells.GetCell(metric, level, partition.GetCell(level, heapNode.node));`
`363`	`362`	`auto source = cell.GetSourceNodes().begin();`
`364`		`- auto distance = [&cell, node = heapNode.node ]() -> auto`
	`363`	`+ auto distance = [&cell, node = heapNode.node]() -> auto`
`365`	`364`	`{`
`366`	`365`	`if constexpr (IS_MAP_MATCHING)`
`367`	`366`	`{`
`@@ -373,8 +372,7 @@ void relaxOutgoingEdges(const DataFacade<Algorithm> &facade,`
`373`	`372`	`boost::ignore_unused(cell, node);`
`374`	`373`	`return 0;`
`375`	`374`	`}`
`376`		`- }`
`377`		`- ();`
	`375`	`+ }();`
`378`	`376`	`for (auto shortcut_weight : cell.GetInWeight(heapNode.node))`
`379`	`377`	`{`
`380`	`378`	`BOOST_ASSERT(source != cell.GetSourceNodes().end());`