remove usage of use-lane completely

src/engine/guidance/lane_processing.cpp

@@ -96,7 +96,7 @@ std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
 
             // only prevent use lanes due to making all turns. don't make turns during curvy
             // segments
-            if (previous_inst.type == TurnType::UseLane)
+            if (previous_inst.type == TurnType::Suppressed)
                 time_to_constrained += previous.duration;
             else
                 time_to_constrained = 0;
@@ -193,8 +193,9 @@ std::vector<RouteStep> anticipateLaneChange(std::vector<RouteStep> steps,
                     anticipate_for_right_turn();
             }
 
-            if (previous_inst.type == TurnType::UseLane && current_inst.type == TurnType::UseLane &&
-                previous.mode == current.mode && previous_lanes == current_lanes)
+            if (previous_inst.type == TurnType::Suppressed &&
+                current_inst.type == TurnType::Suppressed && previous.mode == current.mode &&
+                previous_lanes == current_lanes)
             {
                 previous.ElongateBy(current);
                 current.Invalidate();

src/engine/guidance/post_processing.cpp

@@ -133,8 +133,7 @@ void closeOffRoundabout(const bool on_roundabout,
         BOOST_ASSERT(leavesRoundabout(steps[1].maneuver.instruction) ||
                      steps[1].maneuver.instruction.type == TurnType::StayOnRoundabout ||
                      steps[1].maneuver.instruction.type == TurnType::Suppressed ||
-                     steps[1].maneuver.instruction.type == TurnType::NoTurn ||
-                     steps[1].maneuver.instruction.type == TurnType::UseLane);
+                     steps[1].maneuver.instruction.type == TurnType::NoTurn);
         steps[0].geometry_end = 1;
         steps[1].geometry_begin = 0;
         steps[1].AddInFront(steps[0]);
@@ -608,7 +607,7 @@ std::vector<RouteStep> buildIntersections(std::vector<RouteStep> steps)
     {
         auto &step = steps[step_index];
         const auto instruction = step.maneuver.instruction;
-        if (instruction.type == TurnType::Suppressed || instruction.type == TurnType::UseLane)
+        if (instruction.type == TurnType::Suppressed)
         {
             BOOST_ASSERT(steps[last_valid_instruction].mode == step.mode);
             // count intersections. We cannot use exit, since intersections can follow directly

src/extractor/guidance/turn_lane_augmentation.cpp

@@ -129,19 +129,16 @@ LaneDataVector augmentMultiple(const std::size_t none_index,
             {
                 lane_data.push_back({tag_by_modifier[itr->instruction.direction_modifier],
                                      lane_data[none_index].from,
-                                     lane_data[none_index].from,
-                                     false});
+                                     lane_data[none_index].from});
             }
             lane_data.push_back({tag_by_modifier[straight_itr->instruction.direction_modifier],
                                  lane_data[none_index].from,
-                                 lane_data[none_index].to,
-                                 false});
+                                 lane_data[none_index].to});
             for (auto itr = straight_itr + 1; itr != intersection_range_end; ++itr)
             {
                 lane_data.push_back({tag_by_modifier[itr->instruction.direction_modifier],
                                      lane_data[none_index].to,
-                                     lane_data[none_index].to,
-                                     false});
+                                     lane_data[none_index].to});
             }
 
             lane_data.erase(lane_data.begin() + none_index);
@@ -158,8 +155,7 @@ LaneDataVector augmentMultiple(const std::size_t none_index,
                 lane_data.push_back({tag_by_modifier[intersection[intersection_index]
                                                          .instruction.direction_modifier],
                                      lane_data[none_index].from,
-                                     lane_data[none_index].to,
-                                     false});
+                                     lane_data[none_index].to});
             }
         }
         lane_data.erase(lane_data.begin() + none_index);

src/extractor/guidance/turn_lane_data.cpp

@@ -107,7 +107,7 @@ LaneDataVector laneDataFromDescription(TurnLaneDescription turn_lane_description
     LaneDataVector lane_data;
     lane_data.reserve(lane_map.size());
     for (const auto &tag : lane_map)
-        lane_data.push_back({tag.first, tag.second.first, tag.second.second, false});
+        lane_data.push_back({tag.first, tag.second.first, tag.second.second});
 
     std::sort(lane_data.begin(), lane_data.end());
 

src/extractor/guidance/turn_lane_handler.cpp

@@ -279,7 +279,7 @@ TurnLaneScenario TurnLaneHandler::deduceScenario(const NodeID at,
     // FIXME the lane to add depends on the side of driving/u-turn rules in the country
     if (!lane_data.empty() && canMatchTrivially(intersection, lane_data) &&
         is_missing_valid_u_turn && !hasTag(TurnLaneType::none, lane_data))
-        lane_data.push_back({TurnLaneType::uturn, lane_data.back().to, lane_data.back().to, false});
+        lane_data.push_back({TurnLaneType::uturn, lane_data.back().to, lane_data.back().to});
 
     bool is_simple = isSimpleIntersection(lane_data, intersection);
 
@@ -644,8 +644,6 @@ std::pair<LaneDataVector, LaneDataVector> TurnLaneHandler::partitionLaneData(
         if (lane == straightmost_tag_index)
         {
             augmentEntry(turn_lane_data[straightmost_tag_index]);
-            // disable this turn for assignment if it is a -use lane only
-            turn_lane_data[straightmost_tag_index].suppress_assignment = true;
         }
 
         if (matched_at_first[lane])
@@ -657,7 +655,7 @@ std::pair<LaneDataVector, LaneDataVector> TurnLaneHandler::partitionLaneData(
             std::count(matched_at_second.begin(), matched_at_second.end(), true)) ==
             getNumberOfTurns(next_intersection))
     {
-        TurnLaneData data = {TurnLaneType::straight, 255, 0, true};
+        TurnLaneData data = {TurnLaneType::straight, 255, 0};
         augmentEntry(data);
         first.push_back(data);
         std::sort(first.begin(), first.end());

src/extractor/guidance/turn_lane_matcher.cpp

@@ -87,7 +87,7 @@ bool isValidMatch(const TurnLaneType::Mask tag, const TurnInstruction instructio
                     TurnType::Continue && // Forks can be experienced, even for straight segments
                 (instruction.direction_modifier == DirectionModifier::SlightLeft ||
                  instruction.direction_modifier == DirectionModifier::SlightRight)) ||
-               instruction.type == TurnType::UseLane;
+               instruction.type == TurnType::Suppressed;
     }
     else if (tag == TurnLaneType::slight_left || tag == TurnLaneType::left ||
              tag == TurnLaneType::sharp_left)
@@ -250,10 +250,6 @@ Intersection triviallyMatchLanesToTurns(Intersection intersection,
             BOOST_ASSERT(findBestMatch(lane_data[lane].tag, intersection) ==
                          intersection.begin() + road_index);
 
-            if (TurnType::Suppressed == intersection[road_index].instruction.type &&
-                !lane_data[lane].suppress_assignment)
-                intersection[road_index].instruction.type = TurnType::UseLane;
-
             matchRoad(intersection[road_index], lane_data[lane]);
             ++lane;
         }

src/extractor/scripting_environment_lua.cpp

@@ -176,7 +176,7 @@ void Sol2ScriptingEnvironment::InitContext(LuaScriptingContext &context)
                            "enter_and_exit_roundabout_intersection",
                            extractor::guidance::TurnType::EnterAndExitRoundaboutIntersection,
                            "use_lane",
-                           extractor::guidance::TurnType::UseLane,
+                           extractor::guidance::TurnType::Suppressed,
                            "no_turn",
                            extractor::guidance::TurnType::NoTurn,
                            "suppressed",