[build] Fix clang format and tidy checks

53 files changed, 429 insertions, 582 deletions

diff --git a/include/mbgl/renderer/renderer.hpp b/include/mbgl/renderer/renderer.hpp
index e35c774aa0..7a1ddde1c1 100644
--- a/include/mbgl/renderer/renderer.hpp
+++ b/include/mbgl/renderer/renderer.hpp
@@ -49,20 +49,14 @@ public:
                                                  const std::string& extensionField,
                                                  const optional<std::map<std::string, Value>>& args = {}) const;
 
-    void setFeatureState(const std::string& sourceID,
-                         const optional<std::string>& sourceLayerID,
-                         const std::string& featureID,
-                         const FeatureState& state);
-
-    void getFeatureState(FeatureState& state,
-                         const std::string& sourceID,
-                         const optional<std::string>& sourceLayerID,
+    void setFeatureState(const std::string& sourceID, const optional<std::string>& sourceLayerID,
+                         const std::string& featureID, const FeatureState& state);
+
+    void getFeatureState(FeatureState& state, const std::string& sourceID, const optional<std::string>& sourceLayerID,
                          const std::string& featureID) const;
 
-    void removeFeatureState(const std::string& sourceID,
-                            const optional<std::string>& sourceLayerID,
-                            const optional<std::string>& featureID,
-                            const optional<std::string>& stateKey);
+    void removeFeatureState(const std::string& sourceID, const optional<std::string>& sourceLayerID,
+                            const optional<std::string>& featureID, const optional<std::string>& stateKey);
 
     // Debug
     void dumpDebugLogs();
diff --git a/include/mbgl/style/expression/expression.hpp b/include/mbgl/style/expression/expression.hpp
index 994254fed5..1341a8d041 100644
--- a/include/mbgl/style/expression/expression.hpp
+++ b/include/mbgl/style/expression/expression.hpp
@@ -34,9 +34,8 @@ public:
     EvaluationContext(optional<mbgl::Value> accumulated_, GeometryTileFeature const * feature_) :
         accumulated(std::move(accumulated_)), feature(feature_)
     {}
-    EvaluationContext(float zoom_, GeometryTileFeature const * feature_, const FeatureState* state_) :
-        zoom(zoom_), feature(feature_), featureState(state_)
-    {}
+    EvaluationContext(float zoom_, GeometryTileFeature const* feature_, const FeatureState* state_)
+        : zoom(zoom_), feature(feature_), featureState(state_) {}
     EvaluationContext(optional<float> zoom_, GeometryTileFeature const * feature_, optional<double> colorRampParameter_) :
         zoom(std::move(zoom_)), feature(feature_), colorRampParameter(std::move(colorRampParameter_))
     {}
diff --git a/include/mbgl/util/feature.hpp b/include/mbgl/util/feature.hpp
index d2a23cc5b0..390cc65720 100644
--- a/include/mbgl/util/feature.hpp
+++ b/include/mbgl/util/feature.hpp
@@ -13,7 +13,7 @@ using PropertyMap = mapbox::feature::property_map;
 using FeatureIdentifier = mapbox::feature::identifier;
 using Feature = mapbox::feature::feature<double>;
 using FeatureState = PropertyMap;
-using FeatureStates = std::unordered_map<std::string, FeatureState>; // <featureID, FeatureState>
+using FeatureStates = std::unordered_map<std::string, FeatureState>;       // <featureID, FeatureState>
 using LayerFeatureStates = std::unordered_map<std::string, FeatureStates>; // <sourceLayer, FeatureStates>
 
 template <class T>
@@ -39,21 +39,9 @@ inline optional<std::string> featureIDtoString(const FeatureIdentifier& id) {
     }
 
     return id.match(
-        [] (const std::string& value_) {
-            return value_;
-        },
-        [] (uint64_t value_) {
-            return util::toString(value_);
-        },
-        [] (int64_t value_) {
-            return util::toString(value_);
-        },
-        [] (double value_) {
-            return util::toString(value_);
-        },
-        [] (const auto&) -> optional<std::string> {
-            return nullopt;
-        });
+        [](const std::string& value_) { return value_; }, [](uint64_t value_) { return util::toString(value_); },
+        [](int64_t value_) { return util::toString(value_); }, [](double value_) { return util::toString(value_); },
+        [](const auto&) -> optional<std::string> { return nullopt; });
 }
 
 } // namespace mbgl
diff --git a/platform/glfw/glfw_view.cpp b/platform/glfw/glfw_view.cpp
index 7d05bab43a..c39b2c904a 100644
--- a/platform/glfw/glfw_view.cpp
+++ b/platform/glfw/glfw_view.cpp
@@ -4,24 +4,24 @@
 #include "ny_route.hpp"
 
 #include <mbgl/annotation/annotation.hpp>
-#include <mbgl/style/style.hpp>
-#include <mbgl/style/sources/custom_geometry_source.hpp>
-#include <mbgl/style/sources/geojson_source.hpp>
+#include <mbgl/gfx/backend.hpp>
+#include <mbgl/gfx/backend_scope.hpp>
+#include <mbgl/map/camera.hpp>
+#include <mbgl/renderer/renderer.hpp>
+#include <mbgl/style/expression/dsl.hpp>
 #include <mbgl/style/image.hpp>
-#include <mbgl/style/transition_options.hpp>
 #include <mbgl/style/layers/fill_extrusion_layer.hpp>
-#include <mbgl/style/layers/line_layer.hpp>
 #include <mbgl/style/layers/fill_layer.hpp>
-#include <mbgl/style/expression/dsl.hpp>
+#include <mbgl/style/layers/line_layer.hpp>
+#include <mbgl/style/sources/custom_geometry_source.hpp>
+#include <mbgl/style/sources/geojson_source.hpp>
+#include <mbgl/style/style.hpp>
+#include <mbgl/style/transition_options.hpp>
+#include <mbgl/util/chrono.hpp>
+#include <mbgl/util/geo.hpp>
 #include <mbgl/util/logging.hpp>
 #include <mbgl/util/platform.hpp>
 #include <mbgl/util/string.hpp>
-#include <mbgl/util/chrono.hpp>
-#include <mbgl/util/geo.hpp>
-#include <mbgl/renderer/renderer.hpp>
-#include <mbgl/gfx/backend.hpp>
-#include <mbgl/gfx/backend_scope.hpp>
-#include <mbgl/map/camera.hpp>
 
 #include <mapbox/cheap_ruler.hpp>
 #include <mapbox/geometry.hpp>
@@ -330,7 +330,7 @@ void GLFWView::onKey(GLFWwindow *window, int key, int /*scancode*/, int action,
             using namespace mbgl::style;
             using namespace mbgl::style::expression::dsl;
 
-            auto& style = view->map->getStyle();
+            auto &style = view->map->getStyle();
             if (!style.getSource("states")) {
                 std::string url = "https://docs.mapbox.com/mapbox-gl-js/assets/us_states.geojson";
                 auto source = std::make_unique<GeoJSONSource>("states");
@@ -338,7 +338,7 @@ void GLFWView::onKey(GLFWwindow *window, int key, int /*scancode*/, int action,
                 style.addSource(std::move(source));
 
                 mbgl::CameraOptions cameraOptions;
-                cameraOptions.center = mbgl::LatLng { 42.619626, -103.523181 };
+                cameraOptions.center = mbgl::LatLng{42.619626, -103.523181};
                 cameraOptions.zoom = 3;
                 cameraOptions.pitch = 0;
                 cameraOptions.bearing = 0;
@@ -348,23 +348,27 @@ void GLFWView::onKey(GLFWwindow *window, int key, int /*scancode*/, int action,
             auto layer = style.getLayer("state-fills");
             if (!layer) {
                 auto fillLayer = std::make_unique<FillLayer>("state-fills", "states");
-                fillLayer->setFillColor(mbgl::Color{ 0.0, 0.0, 1.0, 0.5 });
-                fillLayer->setFillOpacity(PropertyExpression<float>(createExpression(R"(["case", ["boolean", ["feature-state", "hover"], false], 1, 0.5])")));
+                fillLayer->setFillColor(mbgl::Color{0.0, 0.0, 1.0, 0.5});
+                fillLayer->setFillOpacity(PropertyExpression<float>(
+                    createExpression(R"(["case", ["boolean", ["feature-state", "hover"], false], 1, 0.5])")));
                 style.addLayer(std::move(fillLayer));
             } else {
-                layer->setVisibility(layer->getVisibility() == mbgl::style::VisibilityType::Visible ?
-                                     mbgl::style::VisibilityType::None : mbgl::style::VisibilityType::Visible);
+                layer->setVisibility(layer->getVisibility() == mbgl::style::VisibilityType::Visible
+                                         ? mbgl::style::VisibilityType::None
+                                         : mbgl::style::VisibilityType::Visible);
             }
 
             layer = style.getLayer("state-borders");
             if (!layer) {
                 auto borderLayer = std::make_unique<LineLayer>("state-borders", "states");
-                borderLayer->setLineColor(mbgl::Color{ 0.0, 0.0, 1.0, 1.0 });
-                borderLayer->setLineWidth(PropertyExpression<float>(createExpression(R"(["case", ["boolean", ["feature-state", "hover"], false], 2, 1])")));
+                borderLayer->setLineColor(mbgl::Color{0.0, 0.0, 1.0, 1.0});
+                borderLayer->setLineWidth(PropertyExpression<float>(
+                    createExpression(R"(["case", ["boolean", ["feature-state", "hover"], false], 2, 1])")));
                 style.addLayer(std::move(borderLayer));
             } else {
-                layer->setVisibility(layer->getVisibility() == mbgl::style::VisibilityType::Visible ?
-                                     mbgl::style::VisibilityType::None : mbgl::style::VisibilityType::Visible);
+                layer->setVisibility(layer->getVisibility() == mbgl::style::VisibilityType::Visible
+                                         ? mbgl::style::VisibilityType::None
+                                         : mbgl::style::VisibilityType::Visible);
             }
         } break;
         }
@@ -581,7 +585,6 @@ void GLFWView::onMouseClick(GLFWwindow *window, int button, int action, int modi
             }
             view->lastClick = now;
         }
-
     }
 }
 
@@ -604,10 +607,10 @@ void GLFWView::onMouseMove(GLFWwindow *window, double x, double y) {
     view->lastX = x;
     view->lastY = y;
 
-    auto& style = view->map->getStyle();
+    auto &style = view->map->getStyle();
     if (style.getLayer("state-fills")) {
-        auto screenCoordinate = mbgl::ScreenCoordinate { view->lastX, view->lastY };
-        const mbgl::RenderedQueryOptions queryOptions({{{ "state-fills" }}, {}});
+        auto screenCoordinate = mbgl::ScreenCoordinate{view->lastX, view->lastY};
+        const mbgl::RenderedQueryOptions queryOptions({{{"state-fills"}}, {}});
         auto result = view->rendererFrontend->getRenderer()->queryRenderedFeatures(screenCoordinate, queryOptions);
         using namespace mbgl;
         FeatureState newState;
@@ -619,20 +622,20 @@ void GLFWView::onMouseMove(GLFWwindow *window, double x, double y) {
             if (idStr) {
                 if (view->featureID && (*view->featureID != *idStr)) {
                     newState["hover"] = false;
-                    view->rendererFrontend->getRenderer()->setFeatureState("states", { }, *view->featureID, newState);
+                    view->rendererFrontend->getRenderer()->setFeatureState("states", {}, *view->featureID, newState);
                     view->featureID = nullopt;
                 }
 
                 if (!view->featureID) {
                     newState["hover"] = true;
                     view->featureID = featureIDtoString(id);
-                    view->rendererFrontend->getRenderer()->setFeatureState("states", { }, *view->featureID, newState);
+                    view->rendererFrontend->getRenderer()->setFeatureState("states", {}, *view->featureID, newState);
                 }
             }
         } else {
             if (view->featureID) {
                 newState["hover"] = false;
-                view->rendererFrontend->getRenderer()->setFeatureState("states", { }, *view->featureID, newState);
+                view->rendererFrontend->getRenderer()->setFeatureState("states", {}, *view->featureID, newState);
                 view->featureID = nullopt;
             }
         }
diff --git a/platform/glfw/glfw_view.hpp b/platform/glfw/glfw_view.hpp
index cc7c821810..dbe6ceb046 100644
--- a/platform/glfw/glfw_view.hpp
+++ b/platform/glfw/glfw_view.hpp
@@ -1,10 +1,10 @@
 #pragma once
 
 #include <mbgl/map/map.hpp>
-#include <mbgl/util/run_loop.hpp>
-#include <mbgl/util/timer.hpp>
 #include <mbgl/util/geometry.hpp>
 #include <mbgl/util/optional.hpp>
+#include <mbgl/util/run_loop.hpp>
+#include <mbgl/util/timer.hpp>
 
 struct GLFWwindow;
 class GLFWBackend;
diff --git a/platform/node/src/node_map.cpp b/platform/node/src/node_map.cpp
index d9bee1c840..7450f461f8 100644
--- a/platform/node/src/node_map.cpp
+++ b/platform/node/src/node_map.cpp
@@ -1135,7 +1135,7 @@ void NodeMap::SetFeatureState(const Nan::FunctionCallbackInfo<v8::Value>& info)
         if (!sourceLayerOption->IsString()) {
             return Nan::ThrowTypeError("SetFeatureState: Requires feature.sourceLayer property to be a string");
         }
-        sourceLayerID = { *Nan::Utf8String(sourceLayerOption) };
+        sourceLayerID = {*Nan::Utf8String(sourceLayerOption)};
     }
 
     if (Nan::Has(feature, Nan::New("id").ToLocalChecked()).FromJust()) {
@@ -1160,7 +1160,8 @@ void NodeMap::SetFeatureState(const Nan::FunctionCallbackInfo<v8::Value>& info)
     bool valueParsed = false;
     FeatureState newState;
 
-    const std::function<optional<Error> (const std::string&, const Convertible&)> convertFn = [&] (const std::string& k, const Convertible& v) -> optional<Error> {
+    const std::function<optional<Error>(const std::string&, const Convertible&)> convertFn =
+        [&](const std::string& k, const Convertible& v) -> optional<Error> {
         optional<Value> value = toValue(v);
         if (value) {
             stateValue = std::move(*value);
@@ -1176,14 +1177,13 @@ void NodeMap::SetFeatureState(const Nan::FunctionCallbackInfo<v8::Value>& info)
                 }
             }
             std::unordered_map<std::string, Value> result;
-            result[k]= std::move(array);
+            result[k] = std::move(array);
             stateValue = std::move(result);
             valueParsed = true;
             return {};
 
         } else if (isObject(v)) {
             eachMember(v, convertFn);
-
         }
         if (!valueParsed) {
             Nan::ThrowTypeError("Could not get feature state value");
@@ -1198,7 +1198,7 @@ void NodeMap::SetFeatureState(const Nan::FunctionCallbackInfo<v8::Value>& info)
 
     try {
         nodeMap->frontend->getRenderer()->setFeatureState(sourceID, sourceLayerID, featureID, newState);
-    } catch (const std::exception &ex) {
+    } catch (const std::exception& ex) {
         return Nan::ThrowError(ex.what());
     }
 
@@ -1235,7 +1235,7 @@ void NodeMap::GetFeatureState(const Nan::FunctionCallbackInfo<v8::Value>& info)
         if (!sourceLayerOption->IsString()) {
             return Nan::ThrowTypeError("GetFeatureState: Requires feature.sourceLayer property to be a string");
         }
-        sourceLayerID = { *Nan::Utf8String(sourceLayerOption) };
+        sourceLayerID = {*Nan::Utf8String(sourceLayerOption)};
     }
 
     if (Nan::Has(feature, Nan::New("id").ToLocalChecked()).FromJust()) {
@@ -1251,7 +1251,7 @@ void NodeMap::GetFeatureState(const Nan::FunctionCallbackInfo<v8::Value>& info)
     mbgl::FeatureState state;
     try {
         nodeMap->frontend->getRenderer()->getFeatureState(state, sourceID, sourceLayerID, featureID);
-    } catch (const std::exception &ex) {
+    } catch (const std::exception& ex) {
         return Nan::ThrowError(ex.what());
     }
 
@@ -1292,7 +1292,7 @@ void NodeMap::RemoveFeatureState(const Nan::FunctionCallbackInfo<v8::Value>& inf
         if (!sourceLayerOption->IsString()) {
             return Nan::ThrowTypeError("RemoveFeatureState: Requires feature.sourceLayer property to be a string");
         }
-        sourceLayerID = { *Nan::Utf8String(sourceLayerOption) };
+        sourceLayerID = {*Nan::Utf8String(sourceLayerOption)};
     }
 
     if (Nan::Has(feature, Nan::New("id").ToLocalChecked()).FromJust()) {
@@ -1300,7 +1300,7 @@ void NodeMap::RemoveFeatureState(const Nan::FunctionCallbackInfo<v8::Value>& inf
         if (!idOption->IsString() && !(idOption->IsNumber() || idOption->IsString())) {
             return Nan::ThrowTypeError("Requires feature.id property to be a string or a number");
         }
-        featureID = { *Nan::Utf8String(idOption) };
+        featureID = {*Nan::Utf8String(idOption)};
     }
 
     if (info.Length() == 2) {
@@ -1308,12 +1308,12 @@ void NodeMap::RemoveFeatureState(const Nan::FunctionCallbackInfo<v8::Value>& inf
         if (!keyParam->IsString()) {
             return Nan::ThrowTypeError("RemoveFeatureState: Requires feature key property to be a string");
         }
-        stateKey = { *Nan::Utf8String(keyParam) };
+        stateKey = {*Nan::Utf8String(keyParam)};
     }
 
     try {
         nodeMap->frontend->getRenderer()->removeFeatureState(sourceID, sourceLayerID, featureID, stateKey);
-    } catch (const std::exception &ex) {
+    } catch (const std::exception& ex) {
         return Nan::ThrowError(ex.what());
     }
 
diff --git a/render-test/runner.cpp b/render-test/runner.cpp
index a9c89dd559..5c8f53759f 100644
--- a/render-test/runner.cpp
+++ b/render-test/runner.cpp
@@ -1,5 +1,6 @@
 #include <mbgl/map/camera.hpp>
 #include <mbgl/map/map_observer.hpp>
+#include <mbgl/renderer/renderer.hpp>
 #include <mbgl/style/conversion/filter.hpp>
 #include <mbgl/style/conversion/layer.hpp>
 #include <mbgl/style/conversion/light.hpp>
@@ -7,15 +8,14 @@
 #include <mbgl/style/image.hpp>
 #include <mbgl/style/layer.hpp>
 #include <mbgl/style/light.hpp>
-#include <mbgl/style/style.hpp>
 #include <mbgl/style/rapidjson_conversion.hpp>
+#include <mbgl/style/style.hpp>
 #include <mbgl/util/chrono.hpp>
-#include <mbgl/util/io.hpp>
 #include <mbgl/util/image.hpp>
+#include <mbgl/util/io.hpp>
 #include <mbgl/util/run_loop.hpp>
 #include <mbgl/util/string.hpp>
 #include <mbgl/util/timer.hpp>
-#include <mbgl/renderer/renderer.hpp>
 
 #include <mapbox/pixelmatch.hpp>
 
@@ -458,7 +458,7 @@ bool TestRunner::runOperations(const std::string& key, TestMetadata& metadata) {
         AllocationIndex::setActive(false);
         AllocationIndex::reset();
 
-    // setFeatureState
+        // setFeatureState
     } else if (operationArray[0].GetString() == setFeatureStateOp) {
         assert(operationArray.Size() >= 3u);
         assert(operationArray[1].IsObject());
@@ -480,14 +480,15 @@ bool TestRunner::runOperations(const std::string& key, TestMetadata& metadata) {
             sourceID = featureOptions["source"].GetString();
         }
         if (featureOptions.HasMember("sourceLayer")) {
-            sourceLayer = { featureOptions["sourceLayer"].GetString() };
+            sourceLayer = {featureOptions["sourceLayer"].GetString()};
         }
         if (featureOptions.HasMember("id")) {
             featureID = featureOptions["id"].GetString();
         }
         const JSValue* state = &operationArray[2];
 
-        const std::function<optional<Error> (const std::string&, const Convertible&)> convertFn = [&] (const std::string& k, const Convertible& v) -> optional<Error> {
+        const std::function<optional<Error>(const std::string&, const Convertible&)> convertFn =
+            [&](const std::string& k, const Convertible& v) -> optional<Error> {
             optional<Value> value = toValue(v);
             if (value) {
                 stateValue = std::move(*value);
@@ -503,7 +504,7 @@ bool TestRunner::runOperations(const std::string& key, TestMetadata& metadata) {
                     }
                 }
                 std::unordered_map<std::string, Value> result;
-                result[k]= std::move(array);
+                result[k] = std::move(array);
                 stateValue = std::move(result);
                 valueParsed = true;
                 return {};
@@ -513,7 +514,7 @@ bool TestRunner::runOperations(const std::string& key, TestMetadata& metadata) {
             }
 
             if (!valueParsed) {
-                metadata.errorMessage = std::string("Could not get feature state value, state key: ")  + k;
+                metadata.errorMessage = std::string("Could not get feature state value, state key: ") + k;
                 return nullopt;
             }
             stateKey = k;
@@ -530,7 +531,7 @@ bool TestRunner::runOperations(const std::string& key, TestMetadata& metadata) {
         }
         frontend.getRenderer()->setFeatureState(sourceID, sourceLayer, featureID, parsedState);
 
-    // getFeatureState
+        // getFeatureState
     } else if (operationArray[0].GetString() == getFeatureStateOp) {
         assert(operationArray.Size() >= 2u);
         assert(operationArray[1].IsObject());
@@ -544,7 +545,7 @@ bool TestRunner::runOperations(const std::string& key, TestMetadata& metadata) {
             sourceID = featureOptions["source"].GetString();
         }
         if (featureOptions.HasMember("sourceLayer")) {
-            sourceLayer = { featureOptions["sourceLayer"].GetString() };
+            sourceLayer = {featureOptions["sourceLayer"].GetString()};
         }
         if (featureOptions.HasMember("id")) {
             featureID = featureOptions["id"].GetString();
@@ -558,7 +559,7 @@ bool TestRunner::runOperations(const std::string& key, TestMetadata& metadata) {
         mbgl::FeatureState state;
         frontend.getRenderer()->getFeatureState(state, sourceID, sourceLayer, featureID);
 
-    // removeFeatureState
+        // removeFeatureState
     } else if (operationArray[0].GetString() == removeFeatureStateOp) {
         assert(operationArray.Size() >= 2u);
         assert(operationArray[1].IsObject());
@@ -573,7 +574,7 @@ bool TestRunner::runOperations(const std::string& key, TestMetadata& metadata) {
             sourceID = featureOptions["source"].GetString();
         }
         if (featureOptions.HasMember("sourceLayer")) {
-            sourceLayer = { featureOptions["sourceLayer"].GetString() };
+            sourceLayer = {featureOptions["sourceLayer"].GetString()};
         }
         if (featureOptions.HasMember("id")) {
             featureID = featureOptions["id"].GetString();
@@ -581,7 +582,7 @@ bool TestRunner::runOperations(const std::string& key, TestMetadata& metadata) {
 
         if (operationArray.Size() >= 3u) {
             assert(operationArray[2].IsString());
-            stateKey = { operationArray[2].GetString() };
+            stateKey = {operationArray[2].GetString()};
         }
 
         try {
diff --git a/src/mbgl/geometry/feature_index.cpp b/src/mbgl/geometry/feature_index.cpp
index 571ff172f8..20026dd117 100644
--- a/src/mbgl/geometry/feature_index.cpp
+++ b/src/mbgl/geometry/feature_index.cpp
@@ -1,14 +1,14 @@
 #include <mbgl/geometry/feature_index.hpp>
-#include <mbgl/renderer/render_layer.hpp>
-#include <mbgl/renderer/query.hpp>
+#include <mbgl/math/minmax.hpp>
 #include <mbgl/renderer/layers/render_symbol_layer.hpp>
+#include <mbgl/renderer/query.hpp>
+#include <mbgl/renderer/render_layer.hpp>
+#include <mbgl/renderer/source_state.hpp>
+#include <mbgl/style/filter.hpp>
 #include <mbgl/text/collision_index.hpp>
+#include <mbgl/tile/tile_id.hpp>
 #include <mbgl/util/constants.hpp>
 #include <mbgl/util/math.hpp>
-#include <mbgl/math/minmax.hpp>
-#include <mbgl/style/filter.hpp>
-#include <mbgl/tile/tile_id.hpp>
-#include <mbgl/renderer/source_state.hpp>
 
 #include <mapbox/geometry/envelope.hpp>
 
@@ -39,19 +39,12 @@ void FeatureIndex::insert(const GeometryCollection& geometries,
     }
 }
 
-void FeatureIndex::query(
-        std::unordered_map<std::string, std::vector<Feature>>& result,
-        const GeometryCoordinates& queryGeometry,
-        const TransformState& transformState,
-        const mat4& posMatrix,
-        const double tileSize,
-        const double scale,
-        const RenderedQueryOptions& queryOptions,
-        const UnwrappedTileID& tileID,
-        const std::unordered_map<std::string, const RenderLayer*>& layers,
-        const float additionalQueryPadding,
-        const SourceFeatureState& sourceFeatureState) const {
-    
+void FeatureIndex::query(std::unordered_map<std::string, std::vector<Feature>>& result,
+                         const GeometryCoordinates& queryGeometry, const TransformState& transformState,
+                         const mat4& posMatrix, const double tileSize, const double scale,
+                         const RenderedQueryOptions& queryOptions, const UnwrappedTileID& tileID,
+                         const std::unordered_map<std::string, const RenderLayer*>& layers,
+                         const float additionalQueryPadding, const SourceFeatureState& sourceFeatureState) const {
     if (!tileData) {
         return;
     }
@@ -76,10 +69,11 @@ void FeatureIndex::query(
         if (indexedFeature.sortIndex == previousSortIndex) continue;
         previousSortIndex = indexedFeature.sortIndex;
 
-        addFeature(result, indexedFeature, queryOptions, tileID.canonical, layers, queryGeometry, transformState, pixelsToTileUnits, posMatrix, &sourceFeatureState);
+        addFeature(result, indexedFeature, queryOptions, tileID.canonical, layers, queryGeometry, transformState,
+                   pixelsToTileUnits, posMatrix, &sourceFeatureState);
     }
 }
-    
+
 std::unordered_map<std::string, std::vector<Feature>>
 FeatureIndex::lookupSymbolFeatures(const std::vector<IndexedSubfeature>& symbolFeatures,
                                    const RenderedQueryOptions& queryOptions,
@@ -115,23 +109,19 @@ FeatureIndex::lookupSymbolFeatures(const std::vector<IndexedSubfeature>& symbolF
 
     for (const auto& symbolFeature : sortedFeatures) {
         mat4 unusedMatrix;
-        addFeature(result, symbolFeature, queryOptions, tileID.canonical, layers, GeometryCoordinates(), {}, 0, unusedMatrix, nullptr);
+        addFeature(result, symbolFeature, queryOptions, tileID.canonical, layers, GeometryCoordinates(), {}, 0,
+                   unusedMatrix, nullptr);
     }
     return result;
 }
 
-void FeatureIndex::addFeature(
-    std::unordered_map<std::string, std::vector<Feature>>& result,
-    const IndexedSubfeature& indexedFeature,
-    const RenderedQueryOptions& options,
-    const CanonicalTileID& tileID,
-    const std::unordered_map<std::string, const RenderLayer*>& layers,
-    const GeometryCoordinates& queryGeometry,
-    const TransformState& transformState,
-    const float pixelsToTileUnits,
-    const mat4& posMatrix,
-    const SourceFeatureState* sourceFeatureState) const {
-
+void FeatureIndex::addFeature(std::unordered_map<std::string, std::vector<Feature>>& result,
+                              const IndexedSubfeature& indexedFeature, const RenderedQueryOptions& options,
+                              const CanonicalTileID& tileID,
+                              const std::unordered_map<std::string, const RenderLayer*>& layers,
+                              const GeometryCoordinates& queryGeometry, const TransformState& transformState,
+                              const float pixelsToTileUnits, const mat4& posMatrix,
+                              const SourceFeatureState* sourceFeatureState) const {
     // Lazily calculated.
     std::unique_ptr<GeometryTileLayer> sourceLayer;
     std::unique_ptr<GeometryTileFeature> geometryTileFeature;
@@ -152,7 +142,7 @@ void FeatureIndex::addFeature(
             assert(geometryTileFeature);
         }
         FeatureState state;
-        if (sourceFeatureState) {
+        if (sourceFeatureState != nullptr) {
             optional<std::string> idStr = featureIDtoString(geometryTileFeature->getID());
             if (idStr) {
                 sourceFeatureState->getState(state, sourceLayer->getName(), *idStr);
@@ -161,7 +151,8 @@ void FeatureIndex::addFeature(
 
         bool needsCrossTileIndex = renderLayer->baseImpl->getTypeInfo()->crossTileIndex == style::LayerTypeInfo::CrossTileIndex::Required;
         if (!needsCrossTileIndex &&
-             !renderLayer->queryIntersectsFeature(queryGeometry, *geometryTileFeature, tileID.z, transformState, pixelsToTileUnits, posMatrix, state)) {
+            !renderLayer->queryIntersectsFeature(queryGeometry, *geometryTileFeature, tileID.z, transformState,
+                                                 pixelsToTileUnits, posMatrix, state)) {
             continue;
         }
 
diff --git a/src/mbgl/geometry/feature_index.hpp b/src/mbgl/geometry/feature_index.hpp
index ab0cfea7db..5a006a51bc 100644
--- a/src/mbgl/geometry/feature_index.hpp
+++ b/src/mbgl/geometry/feature_index.hpp
@@ -59,18 +59,11 @@ public:
     
     void insert(const GeometryCollection&, std::size_t index, const std::string& sourceLayerName, const std::string& bucketLeaderID);
 
-    void query(
-            std::unordered_map<std::string, std::vector<Feature>>& result,
-            const GeometryCoordinates& queryGeometry,
-            const TransformState&,
-            const mat4& posMatrix,
-            const double tileSize,
-            const double scale,
-            const RenderedQueryOptions& options,
-            const UnwrappedTileID&,
-            const std::unordered_map<std::string, const RenderLayer*>&,
-            const float additionalQueryPadding,
-            const SourceFeatureState& sourceFeatureState) const;
+    void query(std::unordered_map<std::string, std::vector<Feature>>& result, const GeometryCoordinates& queryGeometry,
+               const TransformState&, const mat4& posMatrix, const double tileSize, const double scale,
+               const RenderedQueryOptions& options, const UnwrappedTileID&,
+               const std::unordered_map<std::string, const RenderLayer*>&, const float additionalQueryPadding,
+               const SourceFeatureState& sourceFeatureState) const;
 
     static optional<GeometryCoordinates> translateQueryGeometry(
             const GeometryCoordinates& queryGeometry,
@@ -89,17 +82,12 @@ public:
            const std::shared_ptr<std::vector<size_t>>& featureSortOrder) const;
 
 private:
-    void addFeature(
-            std::unordered_map<std::string, std::vector<Feature>>& result,
-            const IndexedSubfeature&,
-            const RenderedQueryOptions& options,
-            const CanonicalTileID&,
-            const std::unordered_map<std::string, const RenderLayer*>&,
-            const GeometryCoordinates& queryGeometry,
-            const TransformState& transformState,
-            const float pixelsToTileUnits,
-            const mat4& posMatrix,
-            const SourceFeatureState* sourceFeatureState) const;
+    void addFeature(std::unordered_map<std::string, std::vector<Feature>>& result, const IndexedSubfeature&,
+                    const RenderedQueryOptions& options, const CanonicalTileID&,
+                    const std::unordered_map<std::string, const RenderLayer*>&,
+                    const GeometryCoordinates& queryGeometry, const TransformState& transformState,
+                    const float pixelsToTileUnits, const mat4& posMatrix,
+                    const SourceFeatureState* sourceFeatureState) const;
 
     GridIndex<IndexedSubfeature> grid;
     unsigned int sortIndex = 0;
diff --git a/src/mbgl/layout/symbol_layout.cpp b/src/mbgl/layout/symbol_layout.cpp
index 71724cad5f..81d1d9a5b6 100644
--- a/src/mbgl/layout/symbol_layout.cpp
+++ b/src/mbgl/layout/symbol_layout.cpp
@@ -713,7 +713,8 @@ void SymbolLayout::createBucket(const ImagePositions&, std::unique_ptr<FeatureIn
             }
 
             for (auto& pair : bucket->paintProperties) {
-                pair.second.iconBinders.populateVertexVectors(feature, iconBuffer.vertices.elements(), symbolInstance.dataFeatureIndex, {}, {});
+                pair.second.iconBinders.populateVertexVectors(feature, iconBuffer.vertices.elements(),
+                                                              symbolInstance.dataFeatureIndex, {}, {});
             }
         }
 
@@ -765,7 +766,8 @@ void SymbolLayout::updatePaintPropertiesForSection(SymbolBucket& bucket,
                                                    std::size_t sectionIndex) {
     const auto& formattedSection = sectionOptionsToValue((*feature.formattedText).sectionAt(sectionIndex));
     for (auto& pair : bucket.paintProperties) {
-        pair.second.textBinders.populateVertexVectors(feature, bucket.text.vertices.elements(), feature.index, {}, {}, formattedSection);
+        pair.second.textBinders.populateVertexVectors(feature, bucket.text.vertices.elements(), feature.index, {}, {},
+                                                      formattedSection);
     }
 }
 
diff --git a/src/mbgl/renderer/bucket.hpp b/src/mbgl/renderer/bucket.hpp
index 98c2200ce9..6c74b8309f 100644
--- a/src/mbgl/renderer/bucket.hpp
+++ b/src/mbgl/renderer/bucket.hpp
@@ -32,15 +32,11 @@ public:
     // Feature geometries are also used to populate the feature index.
     // Obtaining these is a costly operation, so we do it only once, and
     // pass-by-const-ref the geometries as a second parameter.
-    virtual void addFeature(const GeometryTileFeature&,
-                            const GeometryCollection&,
-                            const ImagePositions&,
-                            const PatternLayerMap&,
-                            std::size_t) {};
+    virtual void addFeature(const GeometryTileFeature&, const GeometryCollection&, const ImagePositions&,
+                            const PatternLayerMap&, std::size_t){};
 
     virtual void update(const FeatureStates&, const GeometryTileLayer&, const std::string&, const ImagePositions&) {}
 
-
     // As long as this bucket has a Prepare render pass, this function is getting called. Typically,
     // this only happens once when the bucket is being rendered for the first time.
     virtual void upload(gfx::UploadPass&) = 0;
diff --git a/src/mbgl/renderer/buckets/circle_bucket.cpp b/src/mbgl/renderer/buckets/circle_bucket.cpp
index ffa6f59128..560a74781a 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.cpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.cpp
@@ -41,11 +41,8 @@ bool CircleBucket::hasData() const {
     return !segments.empty();
 }
 
-void CircleBucket::addFeature(const GeometryTileFeature& feature,
-                                 const GeometryCollection& geometry,
-                                 const ImagePositions&,
-                                 const PatternLayerMap&,
-                                 std::size_t featureIndex) {
+void CircleBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry,
+                              const ImagePositions&, const PatternLayerMap&, std::size_t featureIndex) {
     constexpr const uint16_t vertexLength = 4;
 
     for (auto& circle : geometry) {
@@ -115,7 +112,8 @@ float CircleBucket::getQueryRadius(const RenderLayer& layer) const {
     return radius + stroke + util::length(translate[0], translate[1]);
 }
 
-void CircleBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) {
+void CircleBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID,
+                          const ImagePositions& imagePositions) {
     auto it = paintPropertyBinders.find(layerID);
     if (it != paintPropertyBinders.end()) {
         it->second.updateVertexVectors(states, layer, imagePositions);
diff --git a/src/mbgl/renderer/buckets/circle_bucket.hpp b/src/mbgl/renderer/buckets/circle_bucket.hpp
index 9fee45ad79..e514f8a5f2 100644
--- a/src/mbgl/renderer/buckets/circle_bucket.hpp
+++ b/src/mbgl/renderer/buckets/circle_bucket.hpp
@@ -18,11 +18,8 @@ public:
     CircleBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&);
     ~CircleBucket() override;
 
-    void addFeature(const GeometryTileFeature&,
-                    const GeometryCollection&,
-                    const ImagePositions&,
-                    const PatternLayerMap&,
-                    std::size_t) override;
+    void addFeature(const GeometryTileFeature&, const GeometryCollection&, const ImagePositions&,
+                    const PatternLayerMap&, std::size_t) override;
 
     bool hasData() const override;
 
diff --git a/src/mbgl/renderer/buckets/fill_bucket.cpp b/src/mbgl/renderer/buckets/fill_bucket.cpp
index ea79a1e687..6660934f8d 100644
--- a/src/mbgl/renderer/buckets/fill_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_bucket.cpp
@@ -44,10 +44,8 @@ FillBucket::FillBucket(const FillBucket::PossiblyEvaluatedLayoutProperties,
 
 FillBucket::~FillBucket() = default;
 
-void FillBucket::addFeature(const GeometryTileFeature& feature,
-                            const GeometryCollection& geometry,
-                            const ImagePositions& patternPositions,
-                            const PatternLayerMap& patternDependencies,
+void FillBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry,
+                            const ImagePositions& patternPositions, const PatternLayerMap& patternDependencies,
                             std::size_t index) {
     for (auto& polygon : classifyRings(geometry)) {
         // Optimize polygons with many interior rings for earcut tesselation.
@@ -126,7 +124,8 @@ void FillBucket::upload(gfx::UploadPass& uploadPass) {
     if (!uploaded) {
         vertexBuffer = uploadPass.createVertexBuffer(std::move(vertices));
         lineIndexBuffer = uploadPass.createIndexBuffer(std::move(lines));
-        triangleIndexBuffer = triangles.empty() ? optional<gfx::IndexBuffer> {} : uploadPass.createIndexBuffer(std::move(triangles));
+        triangleIndexBuffer =
+            triangles.empty() ? optional<gfx::IndexBuffer>{} : uploadPass.createIndexBuffer(std::move(triangles));
     }
 
     for (auto& pair : paintPropertyBinders) {
@@ -146,7 +145,8 @@ float FillBucket::getQueryRadius(const RenderLayer& layer) const {
     return util::length(translate[0], translate[1]);
 }
 
-void FillBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) {
+void FillBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID,
+                        const ImagePositions& imagePositions) {
     auto it = paintPropertyBinders.find(layerID);
     if (it != paintPropertyBinders.end()) {
         it->second.updateVertexVectors(states, layer, imagePositions);
diff --git a/src/mbgl/renderer/buckets/fill_bucket.hpp b/src/mbgl/renderer/buckets/fill_bucket.hpp
index eee421f938..9f65e774ca 100644
--- a/src/mbgl/renderer/buckets/fill_bucket.hpp
+++ b/src/mbgl/renderer/buckets/fill_bucket.hpp
@@ -26,11 +26,8 @@ public:
                const float zoom,
                const uint32_t overscaling);
 
-    void addFeature(const GeometryTileFeature&,
-                    const GeometryCollection&,
-                    const mbgl::ImagePositions&,
-                    const PatternLayerMap&,
-                    std::size_t) override;
+    void addFeature(const GeometryTileFeature&, const GeometryCollection&, const mbgl::ImagePositions&,
+                    const PatternLayerMap&, std::size_t) override;
 
     bool hasData() const override;
 
diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
index 6a25349c22..698895fdcf 100644
--- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
+++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.cpp
@@ -50,10 +50,8 @@ FillExtrusionBucket::FillExtrusionBucket(const FillExtrusionBucket::PossiblyEval
 
 FillExtrusionBucket::~FillExtrusionBucket() = default;
 
-void FillExtrusionBucket::addFeature(const GeometryTileFeature& feature,
-                                     const GeometryCollection& geometry,
-                                     const ImagePositions& patternPositions,
-                                     const PatternLayerMap& patternDependencies,
+void FillExtrusionBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry,
+                                     const ImagePositions& patternPositions, const PatternLayerMap& patternDependencies,
                                      std::size_t index) {
     for (auto& polygon : classifyRings(geometry)) {
         // Optimize polygons with many interior rings for earcut tesselation.
@@ -189,7 +187,8 @@ float FillExtrusionBucket::getQueryRadius(const RenderLayer& layer) const {
     return util::length(translate[0], translate[1]);
 }
 
-void FillExtrusionBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) {
+void FillExtrusionBucket::update(const FeatureStates& states, const GeometryTileLayer& layer,
+                                 const std::string& layerID, const ImagePositions& imagePositions) {
     auto it = paintPropertyBinders.find(layerID);
     if (it != paintPropertyBinders.end()) {
         it->second.updateVertexVectors(states, layer, imagePositions);
diff --git a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
index 582480bf41..8535f99b70 100644
--- a/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
+++ b/src/mbgl/renderer/buckets/fill_extrusion_bucket.hpp
@@ -24,11 +24,8 @@ public:
                         const float,
                         const uint32_t);
 
-    void addFeature(const GeometryTileFeature&,
-                    const GeometryCollection&,
-                    const mbgl::ImagePositions&,
-                    const PatternLayerMap&,
-                    std::size_t) override;
+    void addFeature(const GeometryTileFeature&, const GeometryCollection&, const mbgl::ImagePositions&,
+                    const PatternLayerMap&, std::size_t) override;
 
     bool hasData() const override;
 
diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.cpp b/src/mbgl/renderer/buckets/heatmap_bucket.cpp
index 0ea645a9a0..78c4fb7507 100644
--- a/src/mbgl/renderer/buckets/heatmap_bucket.cpp
+++ b/src/mbgl/renderer/buckets/heatmap_bucket.cpp
@@ -39,11 +39,8 @@ bool HeatmapBucket::hasData() const {
     return !segments.empty();
 }
 
-void HeatmapBucket::addFeature(const GeometryTileFeature& feature,
-                               const GeometryCollection& geometry,
-                               const ImagePositions&,
-                               const PatternLayerMap&,
-                               std::size_t featureIndex) {
+void HeatmapBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometry,
+                               const ImagePositions&, const PatternLayerMap&, std::size_t featureIndex) {
     constexpr const uint16_t vertexLength = 4;
 
     for (auto& points : geometry) {
diff --git a/src/mbgl/renderer/buckets/heatmap_bucket.hpp b/src/mbgl/renderer/buckets/heatmap_bucket.hpp
index 3f9d1cb5c3..04d4170b50 100644
--- a/src/mbgl/renderer/buckets/heatmap_bucket.hpp
+++ b/src/mbgl/renderer/buckets/heatmap_bucket.hpp
@@ -18,11 +18,8 @@ public:
     HeatmapBucket(const BucketParameters&, const std::vector<Immutable<style::LayerProperties>>&);
     ~HeatmapBucket() override;
 
-    void addFeature(const GeometryTileFeature&,
-                            const GeometryCollection&,
-                            const ImagePositions&,
-                            const PatternLayerMap&,
-                            std::size_t) override;
+    void addFeature(const GeometryTileFeature&, const GeometryCollection&, const ImagePositions&,
+                    const PatternLayerMap&, std::size_t) override;
     bool hasData() const override;
 
     void upload(gfx::UploadPass&) override;
diff --git a/src/mbgl/renderer/buckets/line_bucket.cpp b/src/mbgl/renderer/buckets/line_bucket.cpp
index 318af99b0f..f65c239968 100644
--- a/src/mbgl/renderer/buckets/line_bucket.cpp
+++ b/src/mbgl/renderer/buckets/line_bucket.cpp
@@ -30,10 +30,8 @@ LineBucket::LineBucket(const style::LineLayoutProperties::PossiblyEvaluated layo
 
 LineBucket::~LineBucket() = default;
 
-void LineBucket::addFeature(const GeometryTileFeature& feature,
-                            const GeometryCollection& geometryCollection,
-                            const ImagePositions& patternPositions,
-                            const PatternLayerMap& patternDependencies,
+void LineBucket::addFeature(const GeometryTileFeature& feature, const GeometryCollection& geometryCollection,
+                            const ImagePositions& patternPositions, const PatternLayerMap& patternDependencies,
                             std::size_t index) {
     for (auto& line : geometryCollection) {
         addGeometry(line, feature);
@@ -49,7 +47,6 @@ void LineBucket::addFeature(const GeometryTileFeature& feature,
     }
 }
 
-
 /*
  * Sharp corners cause dashed lines to tilt because the distance along the line
  * is the same at both the inner and outer corners. To improve the appearance of
@@ -557,7 +554,8 @@ float LineBucket::getQueryRadius(const RenderLayer& layer) const {
     return lineWidth / 2.0f + std::abs(offset) + util::length(translate[0], translate[1]);
 }
 
-void LineBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID, const ImagePositions& imagePositions) {
+void LineBucket::update(const FeatureStates& states, const GeometryTileLayer& layer, const std::string& layerID,
+                        const ImagePositions& imagePositions) {
     auto it = paintPropertyBinders.find(layerID);
     if (it != paintPropertyBinders.end()) {
         it->second.updateVertexVectors(states, layer, imagePositions);
diff --git a/src/mbgl/renderer/buckets/line_bucket.hpp b/src/mbgl/renderer/buckets/line_bucket.hpp
index 6be35593d9..6343aab2be 100644
--- a/src/mbgl/renderer/buckets/line_bucket.hpp
+++ b/src/mbgl/renderer/buckets/line_bucket.hpp
@@ -26,11 +26,8 @@ public:
                const uint32_t overscaling);
     ~LineBucket() override;
 
-    void addFeature(const GeometryTileFeature&,
-                    const GeometryCollection&,
-                    const mbgl::ImagePositions& patternPositions,
-                    const PatternLayerMap&,
-                    std::size_t) override;
+    void addFeature(const GeometryTileFeature&, const GeometryCollection&, const mbgl::ImagePositions& patternPositions,
+                    const PatternLayerMap&, std::size_t) override;
 
     bool hasData() const override;
 
diff --git a/src/mbgl/renderer/layers/render_circle_layer.cpp b/src/mbgl/renderer/layers/render_circle_layer.cpp
index 76dadd80bf..b88a026e11 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.cpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.cpp
@@ -141,14 +141,10 @@ GeometryCoordinates projectQueryGeometry(const GeometryCoordinates& queryGeometr
     return projectedGeometry;
 }
 
-bool RenderCircleLayer::queryIntersectsFeature(
-        const GeometryCoordinates& queryGeometry,
-        const GeometryTileFeature& feature,
-        const float zoom,
-        const TransformState& transformState,
-        const float pixelsToTileUnits,
-        const mat4& posMatrix,
-        const FeatureState& featureState) const {
+bool RenderCircleLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry,
+                                               const GeometryTileFeature& feature, const float zoom,
+                                               const TransformState& transformState, const float pixelsToTileUnits,
+                                               const mat4& posMatrix, const FeatureState& featureState) const {
     const auto& evaluated = static_cast<const CircleLayerProperties&>(*evaluatedProperties).evaluated;
     // Translate query geometry
     const GeometryCoordinates& translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
diff --git a/src/mbgl/renderer/layers/render_circle_layer.hpp b/src/mbgl/renderer/layers/render_circle_layer.hpp
index ee0318da7c..70af20f0cf 100644
--- a/src/mbgl/renderer/layers/render_circle_layer.hpp
+++ b/src/mbgl/renderer/layers/render_circle_layer.hpp
@@ -18,14 +18,8 @@ private:
     bool hasCrossfade() const override;
     void render(PaintParameters&) override;
 
-    bool queryIntersectsFeature(
-            const GeometryCoordinates&,
-            const GeometryTileFeature&,
-            const float,
-            const TransformState&,
-            const float,
-            const mat4&,
-            const FeatureState&) const override;
+    bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float,
+                                const TransformState&, const float, const mat4&, const FeatureState&) const override;
 
     // Paint properties
     style::CirclePaintProperties::Unevaluated unevaluated;
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
index b6ffa3f8f9..fc830e462c 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.cpp
@@ -224,14 +224,11 @@ void RenderFillExtrusionLayer::render(PaintParameters& parameters) {
     }
 }
 
-bool RenderFillExtrusionLayer::queryIntersectsFeature(
-        const GeometryCoordinates& queryGeometry,
-        const GeometryTileFeature& feature,
-        const float,
-        const TransformState& transformState,
-        const float pixelsToTileUnits,
-        const mat4&,
-        const FeatureState&) const {
+bool RenderFillExtrusionLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry,
+                                                      const GeometryTileFeature& feature, const float,
+                                                      const TransformState& transformState,
+                                                      const float pixelsToTileUnits, const mat4&,
+                                                      const FeatureState&) const {
     const auto& evaluated = static_cast<const FillExtrusionLayerProperties&>(*evaluatedProperties).evaluated;
     auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
             queryGeometry,
diff --git a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
index bad2c26122..0e6a747c71 100644
--- a/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_extrusion_layer.hpp
@@ -20,14 +20,8 @@ private:
     bool is3D() const override;
     void render(PaintParameters&) override;
 
-    bool queryIntersectsFeature(
-        const GeometryCoordinates&,
-        const GeometryTileFeature&,
-        const float,
-        const TransformState&,
-        const float,
-        const mat4&,
-        const FeatureState&) const override;
+    bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float,
+                                const TransformState&, const float, const mat4&, const FeatureState&) const override;
 
     // Paint properties
     style::FillExtrusionPaintProperties::Unevaluated unevaluated;
diff --git a/src/mbgl/renderer/layers/render_fill_layer.cpp b/src/mbgl/renderer/layers/render_fill_layer.cpp
index 40b3c289f2..e855866eea 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.cpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.cpp
@@ -249,14 +249,10 @@ void RenderFillLayer::render(PaintParameters& parameters) {
     }
 }
 
-bool RenderFillLayer::queryIntersectsFeature(
-        const GeometryCoordinates& queryGeometry,
-        const GeometryTileFeature& feature,
-        const float,
-        const TransformState& transformState,
-        const float pixelsToTileUnits,
-        const mat4&,
-        const FeatureState&) const {
+bool RenderFillLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry,
+                                             const GeometryTileFeature& feature, const float,
+                                             const TransformState& transformState, const float pixelsToTileUnits,
+                                             const mat4&, const FeatureState&) const {
     const auto& evaluated = getEvaluated<FillLayerProperties>(evaluatedProperties);
     auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
             queryGeometry,
@@ -268,5 +264,4 @@ bool RenderFillLayer::queryIntersectsFeature(
     return util::polygonIntersectsMultiPolygon(translatedQueryGeometry.value_or(queryGeometry), feature.getGeometries());
 }
 
-
 } // namespace mbgl
diff --git a/src/mbgl/renderer/layers/render_fill_layer.hpp b/src/mbgl/renderer/layers/render_fill_layer.hpp
index 182e0c544c..12484dbfb1 100644
--- a/src/mbgl/renderer/layers/render_fill_layer.hpp
+++ b/src/mbgl/renderer/layers/render_fill_layer.hpp
@@ -21,14 +21,8 @@ private:
     bool hasCrossfade() const override;
     void render(PaintParameters&) override;
 
-    bool queryIntersectsFeature(
-            const GeometryCoordinates&,
-            const GeometryTileFeature&,
-            const float,
-            const TransformState&,
-            const float,
-            const mat4&,
-            const FeatureState&) const override;
+    bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float,
+                                const TransformState&, const float, const mat4&, const FeatureState&) const override;
 
     // Paint properties
     style::FillPaintProperties::Unevaluated unevaluated;
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.cpp b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
index 777269f9db..797aedd297 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.cpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.cpp
@@ -219,14 +219,10 @@ void RenderHeatmapLayer::updateColorRamp() {
     }
 }
 
-bool RenderHeatmapLayer::queryIntersectsFeature(
-        const GeometryCoordinates& queryGeometry,
-        const GeometryTileFeature& feature,
-        const float zoom,
-        const TransformState&,
-        const float pixelsToTileUnits,
-        const mat4&,
-        const FeatureState&) const {
+bool RenderHeatmapLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry,
+                                                const GeometryTileFeature& feature, const float zoom,
+                                                const TransformState&, const float pixelsToTileUnits, const mat4&,
+                                                const FeatureState&) const {
     (void) queryGeometry;
     (void) feature;
     (void) zoom;
diff --git a/src/mbgl/renderer/layers/render_heatmap_layer.hpp b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
index 1c1eb67ad5..1e9b1063ae 100644
--- a/src/mbgl/renderer/layers/render_heatmap_layer.hpp
+++ b/src/mbgl/renderer/layers/render_heatmap_layer.hpp
@@ -22,14 +22,8 @@ private:
     void upload(gfx::UploadPass&) override;
     void render(PaintParameters&) override;
 
-    bool queryIntersectsFeature(
-            const GeometryCoordinates&,
-            const GeometryTileFeature&,
-            const float,
-            const TransformState&,
-            const float,
-            const mat4&,
-            const FeatureState&) const override;
+    bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float,
+                                const TransformState&, const float, const mat4&, const FeatureState&) const override;
 
     // Paint properties
     style::HeatmapPaintProperties::Unevaluated unevaluated;
diff --git a/src/mbgl/renderer/layers/render_line_layer.cpp b/src/mbgl/renderer/layers/render_line_layer.cpp
index fe3ca00f06..36665c1db4 100644
--- a/src/mbgl/renderer/layers/render_line_layer.cpp
+++ b/src/mbgl/renderer/layers/render_line_layer.cpp
@@ -257,14 +257,10 @@ GeometryCollection offsetLine(const GeometryCollection& rings, double offset) {
 
 } // namespace
 
-bool RenderLineLayer::queryIntersectsFeature(
-        const GeometryCoordinates& queryGeometry,
-        const GeometryTileFeature& feature,
-        const float zoom,
-        const TransformState& transformState,
-        const float pixelsToTileUnits,
-        const mat4&,
-        const FeatureState& featureState) const {
+bool RenderLineLayer::queryIntersectsFeature(const GeometryCoordinates& queryGeometry,
+                                             const GeometryTileFeature& feature, const float zoom,
+                                             const TransformState& transformState, const float pixelsToTileUnits,
+                                             const mat4&, const FeatureState& featureState) const {
     const auto& evaluated = static_cast<const LineLayerProperties&>(*evaluatedProperties).evaluated;
     // Translate query geometry
     auto translatedQueryGeometry = FeatureIndex::translateQueryGeometry(
@@ -275,10 +271,11 @@ bool RenderLineLayer::queryIntersectsFeature(
             pixelsToTileUnits);
 
     // Evaluate function
-    auto offset = evaluated.get<style::LineOffset>()
-                          .evaluate(feature, zoom, featureState, style::LineOffset::defaultValue()) * pixelsToTileUnits;
+    auto offset =
+        evaluated.get<style::LineOffset>().evaluate(feature, zoom, featureState, style::LineOffset::defaultValue()) *
+        pixelsToTileUnits;
     // Test intersection
-    const float halfWidth = getLineWidth(feature, zoom, featureState) / 2.0 * pixelsToTileUnits;
+    const auto halfWidth = static_cast<float>(getLineWidth(feature, zoom, featureState) / 2.0 * pixelsToTileUnits);
 
     // Apply offset to geometry
     if (offset != 0.0f && !feature.getGeometries().empty()) {
@@ -315,12 +312,13 @@ void RenderLineLayer::updateColorRamp() {
     }
 }
 
-float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom, const FeatureState& featureState) const {
+float RenderLineLayer::getLineWidth(const GeometryTileFeature& feature, const float zoom,
+                                    const FeatureState& featureState) const {
     const auto& evaluated = static_cast<const LineLayerProperties&>(*evaluatedProperties).evaluated;
-    float lineWidth = evaluated.get<style::LineWidth>()
-            .evaluate(feature, zoom, featureState, style::LineWidth::defaultValue());
-    float gapWidth = evaluated.get<style::LineGapWidth>()
-            .evaluate(feature, zoom, featureState, style::LineGapWidth::defaultValue());
+    float lineWidth =
+        evaluated.get<style::LineWidth>().evaluate(feature, zoom, featureState, style::LineWidth::defaultValue());
+    float gapWidth =
+        evaluated.get<style::LineGapWidth>().evaluate(feature, zoom, featureState, style::LineGapWidth::defaultValue());
     if (gapWidth) {
         return gapWidth + 2 * lineWidth;
     } else {
diff --git a/src/mbgl/renderer/layers/render_line_layer.hpp b/src/mbgl/renderer/layers/render_line_layer.hpp
index d4d84eb34e..1914a82b77 100644
--- a/src/mbgl/renderer/layers/render_line_layer.hpp
+++ b/src/mbgl/renderer/layers/render_line_layer.hpp
@@ -24,14 +24,8 @@ private:
     void upload(gfx::UploadPass&) override;
     void render(PaintParameters&) override;
 
-    bool queryIntersectsFeature(
-            const GeometryCoordinates&,
-            const GeometryTileFeature&,
-            const float,
-            const TransformState&,
-            const float,
-            const mat4&,
-            const FeatureState&) const override;
+    bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float,
+                                const TransformState&, const float, const mat4&, const FeatureState&) const override;
 
     // Paint properties
     style::LinePaintProperties::Unevaluated unevaluated;
diff --git a/src/mbgl/renderer/paint_property_binder.hpp b/src/mbgl/renderer/paint_property_binder.hpp
index fdfbc99642..1a36f8a2e5 100644
--- a/src/mbgl/renderer/paint_property_binder.hpp
+++ b/src/mbgl/renderer/paint_property_binder.hpp
@@ -105,15 +105,11 @@ public:
 
     virtual ~PaintPropertyBinder() = default;
 
-    virtual void populateVertexVector(const GeometryTileFeature& feature,
-                                      std::size_t length, std::size_t index,
-                                      const ImagePositions&,
-                                      const optional<PatternDependency>&,
+    virtual void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index,
+                                      const ImagePositions&, const optional<PatternDependency>&,
                                       const style::expression::Value&) = 0;
 
-    virtual void updateVertexVectors(const FeatureStates&,
-                                     const GeometryTileLayer&,
-                                     const ImagePositions&) {}
+    virtual void updateVertexVectors(const FeatureStates&, const GeometryTileLayer&, const ImagePositions&) {}
 
     virtual void updateVertexVector(std::size_t, std::size_t, const GeometryTileFeature&, const FeatureState&) = 0;
 
@@ -135,7 +131,8 @@ public:
         : constant(std::move(constant_)) {
     }
 
-    void populateVertexVector(const GeometryTileFeature&, std::size_t, std::size_t, const ImagePositions&, const optional<PatternDependency>&, const style::expression::Value&) override {}
+    void populateVertexVector(const GeometryTileFeature&, std::size_t, std::size_t, const ImagePositions&,
+                              const optional<PatternDependency>&, const style::expression::Value&) override {}
     void updateVertexVector(std::size_t, std::size_t, const GeometryTileFeature&, const FeatureState&) override {}
     void upload(gfx::UploadPass&) override {}
     void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, const CrossfadeParameters&) override {};
@@ -163,7 +160,8 @@ public:
         : constant(std::move(constant_)), constantPatternPositions({}) {
     }
 
-    void populateVertexVector(const GeometryTileFeature&, std::size_t, std::size_t, const ImagePositions&, const optional<PatternDependency>&, const style::expression::Value&) override {}
+    void populateVertexVector(const GeometryTileFeature&, std::size_t, std::size_t, const ImagePositions&,
+                              const optional<PatternDependency>&, const style::expression::Value&) override {}
     void updateVertexVector(std::size_t, std::size_t, const GeometryTileFeature&, const FeatureState&) override {}
     void upload(gfx::UploadPass&) override {}
 
@@ -206,7 +204,9 @@ public:
           defaultValue(std::move(defaultValue_)) {
     }
     void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, const CrossfadeParameters&) override {};
-    void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index, const ImagePositions&, const optional<PatternDependency>&, const style::expression::Value& formattedSection) override {
+    void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index,
+                              const ImagePositions&, const optional<PatternDependency>&,
+                              const style::expression::Value& formattedSection) override {
         using style::expression::EvaluationContext;
         auto evaluated = expression.evaluate(EvaluationContext(&feature).withFormattedSection(&formattedSection), defaultValue);
         this->statistics.add(evaluated);
@@ -217,11 +217,12 @@ public:
         }
         optional<std::string> idStr = featureIDtoString(feature.getID());
         if (idStr) {
-            featureMap[*idStr].emplace_back(FeatureVertexRange { index, elements, length });
+            featureMap[*idStr].emplace_back(FeatureVertexRange{index, elements, length});
         }
     }
 
-    void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, const ImagePositions&) override {
+    void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer,
+                             const ImagePositions&) override {
         for (const auto& it : states) {
             const auto positions = featureMap.find(it.first);
             if (positions == featureMap.end()) {
@@ -237,14 +238,15 @@ public:
         }
     }
 
-    void updateVertexVector(std::size_t start, std::size_t end, const GeometryTileFeature& feature, const FeatureState& state) override {
+    void updateVertexVector(std::size_t start, std::size_t end, const GeometryTileFeature& feature,
+                            const FeatureState& state) override {
         using style::expression::EvaluationContext;
 
         auto evaluated = expression.evaluate(EvaluationContext(&feature).withFeatureState(&state), defaultValue);
         this->statistics.add(evaluated);
         auto value = attributeValue(evaluated);
         for (std::size_t i = start; i < end; ++i) {
-            vertexVector.at(i) = BaseVertex { value };
+            vertexVector.at(i) = BaseVertex{value};
         }
     }
 
@@ -297,7 +299,9 @@ public:
           zoomRange({zoom, zoom + 1}) {
     }
     void setPatternParameters(const optional<ImagePosition>&, const optional<ImagePosition>&, const CrossfadeParameters&) override {};
-    void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index, const ImagePositions&, const optional<PatternDependency>&, const style::expression::Value& formattedSection) override {
+    void populateVertexVector(const GeometryTileFeature& feature, std::size_t length, std::size_t index,
+                              const ImagePositions&, const optional<PatternDependency>&,
+                              const style::expression::Value& formattedSection) override {
         using style::expression::EvaluationContext;
         Range<T> range = {
                 expression.evaluate(EvaluationContext(zoomRange.min, &feature).withFormattedSection(&formattedSection), defaultValue),
@@ -314,11 +318,12 @@ public:
         }
         optional<std::string> idStr = featureIDtoString(feature.getID());
         if (idStr) {
-            featureMap[*idStr].emplace_back(FeatureVertexRange { index, elements, length });
+            featureMap[*idStr].emplace_back(FeatureVertexRange{index, elements, length});
         }
     }
 
-    void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, const ImagePositions&) override {
+    void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer,
+                             const ImagePositions&) override {
         for (const auto& it : states) {
             const auto positions = featureMap.find(it.first);
             if (positions == featureMap.end()) {
@@ -334,20 +339,19 @@ public:
         }
     }
 
-    void updateVertexVector(std::size_t start, std::size_t end, const GeometryTileFeature& feature, const FeatureState& state) override {
+    void updateVertexVector(std::size_t start, std::size_t end, const GeometryTileFeature& feature,
+                            const FeatureState& state) override {
         using style::expression::EvaluationContext;
         Range<T> range = {
-                expression.evaluate(EvaluationContext(zoomRange.min, &feature, &state), defaultValue),
-                expression.evaluate(EvaluationContext(zoomRange.max, &feature, &state), defaultValue),
+            expression.evaluate(EvaluationContext(zoomRange.min, &feature, &state), defaultValue),
+            expression.evaluate(EvaluationContext(zoomRange.max, &feature, &state), defaultValue),
         };
         this->statistics.add(range.min);
         this->statistics.add(range.max);
-        AttributeValue value = zoomInterpolatedAttributeValue(
-            attributeValue(range.min),
-            attributeValue(range.max));
+        AttributeValue value = zoomInterpolatedAttributeValue(attributeValue(range.min), attributeValue(range.max));
 
         for (std::size_t i = start; i < end; ++i) {
-            vertexVector.at(i) = Vertex { value };
+            vertexVector.at(i) = Vertex{value};
         }
     }
 
@@ -413,8 +417,10 @@ public:
         crossfade = crossfade_;
     };
 
-    void populateVertexVector(const GeometryTileFeature&, std::size_t length, std::size_t /* index */, const ImagePositions& patternPositions, const optional<PatternDependency>& patternDependencies, const style::expression::Value&) override {
-    
+    void populateVertexVector(const GeometryTileFeature&, std::size_t length, std::size_t /* index */,
+                              const ImagePositions& patternPositions,
+                              const optional<PatternDependency>& patternDependencies,
+                              const style::expression::Value&) override {
         if (!patternDependencies || patternDependencies->mid.empty())  {
             // Unlike other propperties with expressions that evaluate to null, the default value for `*-pattern` properties is an empty
             // string and will not have a valid entry in patternPositions. We still need to populate the attribute buffers to avoid crashes
@@ -584,16 +590,18 @@ public:
     PaintPropertyBinders(PaintPropertyBinders&&) = default;
     PaintPropertyBinders(const PaintPropertyBinders&) = delete;
 
-    void populateVertexVectors(const GeometryTileFeature& feature, std::size_t length, std::size_t index, const ImagePositions& patternPositions, const optional<PatternDependency>& patternDependencies, const style::expression::Value& formattedSection = {}) {
-        util::ignore({
-            (binders.template get<Ps>()->populateVertexVector(feature, length, index, patternPositions, patternDependencies, formattedSection), 0)...
-        });
+    void populateVertexVectors(const GeometryTileFeature& feature, std::size_t length, std::size_t index,
+                               const ImagePositions& patternPositions,
+                               const optional<PatternDependency>& patternDependencies,
+                               const style::expression::Value& formattedSection = {}) {
+        util::ignore({(binders.template get<Ps>()->populateVertexVector(feature, length, index, patternPositions,
+                                                                        patternDependencies, formattedSection),
+                       0)...});
     }
 
-    void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer, const ImagePositions& imagePositions) {
-        util::ignore({
-            (binders.template get<Ps>()->updateVertexVectors(states, layer, imagePositions), 0)...
-        });
+    void updateVertexVectors(const FeatureStates& states, const GeometryTileLayer& layer,
+                             const ImagePositions& imagePositions) {
+        util::ignore({(binders.template get<Ps>()->updateVertexVectors(states, layer, imagePositions), 0)...});
     }
 
     void setPatternParameters(const optional<ImagePosition>& posA, const optional<ImagePosition>& posB, const CrossfadeParameters& crossfade) const {
diff --git a/src/mbgl/renderer/possibly_evaluated_property_value.hpp b/src/mbgl/renderer/possibly_evaluated_property_value.hpp
index 2e47e6c854..1198e43aae 100644
--- a/src/mbgl/renderer/possibly_evaluated_property_value.hpp
+++ b/src/mbgl/renderer/possibly_evaluated_property_value.hpp
@@ -52,12 +52,10 @@ public:
 
     template <class Feature>
     T evaluate(const Feature& feature, float zoom, const FeatureState& featureState, T defaultValue) const {
-        return this->match(
-            [&] (const T& constant_) { return constant_; },
-            [&] (const style::PropertyExpression<T>& expression) {
-                return expression.evaluate(zoom, feature, featureState, defaultValue);
-            }
-        );
+        return this->match([&](const T& constant_) { return constant_; },
+                           [&](const style::PropertyExpression<T>& expression) {
+                               return expression.evaluate(zoom, feature, featureState, defaultValue);
+                           });
     }
 };
 
diff --git a/src/mbgl/renderer/render_layer.hpp b/src/mbgl/renderer/render_layer.hpp
index 2b65d069ae..ba3c638f88 100644
--- a/src/mbgl/renderer/render_layer.hpp
+++ b/src/mbgl/renderer/render_layer.hpp
@@ -88,14 +88,10 @@ public:
 
     // Check wether the given geometry intersects
     // with the feature
-    virtual bool queryIntersectsFeature(
-            const GeometryCoordinates&,
-            const GeometryTileFeature&,
-            const float,
-            const TransformState&,
-            const float,
-            const mat4&,
-            const FeatureState&) const { return false; };
+    virtual bool queryIntersectsFeature(const GeometryCoordinates&, const GeometryTileFeature&, const float,
+                                        const TransformState&, const float, const mat4&, const FeatureState&) const {
+        return false;
+    };
 
     virtual void prepare(const LayerPrepareParameters&);
 
diff --git a/src/mbgl/renderer/render_orchestrator.cpp b/src/mbgl/renderer/render_orchestrator.cpp
index 6bccee7798..a1280331b1 100644
--- a/src/mbgl/renderer/render_orchestrator.cpp
+++ b/src/mbgl/renderer/render_orchestrator.cpp
@@ -562,17 +562,14 @@ FeatureExtensionValue RenderOrchestrator::queryFeatureExtensions(const std::stri
     return {};
 }
 
-void RenderOrchestrator::setFeatureState(const std::string& sourceID,
-                                         const optional<std::string>& sourceLayerID,
-                                         const std::string& featureID,
-                                         const FeatureState& state) {
+void RenderOrchestrator::setFeatureState(const std::string& sourceID, const optional<std::string>& sourceLayerID,
+                                         const std::string& featureID, const FeatureState& state) {
     if (RenderSource* renderSource = getRenderSource(sourceID)) {
         renderSource->setFeatureState(sourceLayerID, featureID, state);
     }
 }
 
-void RenderOrchestrator::getFeatureState(FeatureState& state,
-                                         const std::string& sourceID,
+void RenderOrchestrator::getFeatureState(FeatureState& state, const std::string& sourceID,
                                          const optional<std::string>& sourceLayerID,
                                          const std::string& featureID) const {
     if (RenderSource* renderSource = getRenderSource(sourceID)) {
@@ -580,8 +577,7 @@ void RenderOrchestrator::getFeatureState(FeatureState& state,
     }
 }
 
-void RenderOrchestrator::removeFeatureState(const std::string& sourceID,
-                                            const optional<std::string>& sourceLayerID,
+void RenderOrchestrator::removeFeatureState(const std::string& sourceID, const optional<std::string>& sourceLayerID,
                                             const optional<std::string>& featureID,
                                             const optional<std::string>& stateKey) {
     if (RenderSource* renderSource = getRenderSource(sourceID)) {
diff --git a/src/mbgl/renderer/render_orchestrator.hpp b/src/mbgl/renderer/render_orchestrator.hpp
index f42a40ec33..34b623348f 100644
--- a/src/mbgl/renderer/render_orchestrator.hpp
+++ b/src/mbgl/renderer/render_orchestrator.hpp
@@ -64,20 +64,14 @@ public:
                                                  const std::string& extensionField,
                                                  const optional<std::map<std::string, Value>>& args) const;
 
-    void setFeatureState(const std::string& sourceID,
-                         const optional<std::string>& layerID,
-                         const std::string& featureID,
-                         const FeatureState& state);
-
-    void getFeatureState(FeatureState& state,
-                         const std::string& sourceID,
-                         const optional<std::string>& layerID,
+    void setFeatureState(const std::string& sourceID, const optional<std::string>& layerID,
+                         const std::string& featureID, const FeatureState& state);
+
+    void getFeatureState(FeatureState& state, const std::string& sourceID, const optional<std::string>& layerID,
                          const std::string& featureID) const;
 
-    void removeFeatureState(const std::string& sourceID,
-                            const optional<std::string>& sourceLayerID,
-                            const optional<std::string>& featureID,
-                            const optional<std::string>& stateKey);
+    void removeFeatureState(const std::string& sourceID, const optional<std::string>& sourceLayerID,
+                            const optional<std::string>& featureID, const optional<std::string>& stateKey);
 
     void reduceMemoryUse();
     void dumpDebugLogs();
diff --git a/src/mbgl/renderer/render_source.hpp b/src/mbgl/renderer/render_source.hpp
index 39ca97d563..ee90e1c4d0 100644
--- a/src/mbgl/renderer/render_source.hpp
+++ b/src/mbgl/renderer/render_source.hpp
@@ -93,16 +93,11 @@ public:
         return {};
     }
 
-    virtual void setFeatureState(const optional<std::string>&,
-                                const std::string&,
-                                const FeatureState&) {}
+    virtual void setFeatureState(const optional<std::string>&, const std::string&, const FeatureState&) {}
 
-    virtual void getFeatureState(FeatureState&,
-                                 const optional<std::string>&,
-                                 const std::string&) const {}
+    virtual void getFeatureState(FeatureState&, const optional<std::string>&, const std::string&) const {}
 
-    virtual void removeFeatureState(const optional<std::string>&,
-                                    const optional<std::string>&,
+    virtual void removeFeatureState(const optional<std::string>&, const optional<std::string>&,
                                     const optional<std::string>&) {}
 
     virtual void reduceMemoryUse() = 0;
diff --git a/src/mbgl/renderer/renderer.cpp b/src/mbgl/renderer/renderer.cpp
index a91a0098ca..cf4072036c 100644
--- a/src/mbgl/renderer/renderer.cpp
+++ b/src/mbgl/renderer/renderer.cpp
@@ -109,24 +109,18 @@ FeatureExtensionValue Renderer::queryFeatureExtensions(const std::string& source
     return impl->orchestrator.queryFeatureExtensions(sourceID, feature, extension, extensionField, args);
 }
 
-void Renderer::setFeatureState(const std::string& sourceID,
-                               const optional<std::string>& sourceLayerID,
-                               const std::string& featureID,
-                               const FeatureState& state) {
+void Renderer::setFeatureState(const std::string& sourceID, const optional<std::string>& sourceLayerID,
+                               const std::string& featureID, const FeatureState& state) {
     impl->orchestrator.setFeatureState(sourceID, sourceLayerID, featureID, state);
 }
 
-void Renderer::getFeatureState(FeatureState& state,
-                               const std::string& sourceID,
-                               const optional<std::string>& sourceLayerID,
-                               const std::string& featureID) const {
+void Renderer::getFeatureState(FeatureState& state, const std::string& sourceID,
+                               const optional<std::string>& sourceLayerID, const std::string& featureID) const {
     impl->orchestrator.getFeatureState(state, sourceID, sourceLayerID, featureID);
 }
 
-void Renderer::removeFeatureState(const std::string& sourceID,
-                                  const optional<std::string>& sourceLayerID,
-                                  const optional<std::string>& featureID,
-                                  const optional<std::string>& stateKey) {
+void Renderer::removeFeatureState(const std::string& sourceID, const optional<std::string>& sourceLayerID,
+                                  const optional<std::string>& featureID, const optional<std::string>& stateKey) {
     impl->orchestrator.removeFeatureState(sourceID, sourceLayerID, featureID, stateKey);
 }
 
diff --git a/src/mbgl/renderer/source_state.cpp b/src/mbgl/renderer/source_state.cpp
index c1b95aca68..d057c211b5 100644
--- a/src/mbgl/renderer/source_state.cpp
+++ b/src/mbgl/renderer/source_state.cpp
@@ -1,11 +1,12 @@
+#include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/renderer/source_state.hpp>
 #include <mbgl/style/conversion_impl.hpp>
-#include <mbgl/renderer/render_tile.hpp>
 #include <mbgl/util/logging.hpp>
 
 namespace mbgl {
 
-void SourceFeatureState::updateState(const optional<std::string>& sourceLayerID, const std::string& featureID, const FeatureState& newState) {
+void SourceFeatureState::updateState(const optional<std::string>& sourceLayerID, const std::string& featureID,
+                                     const FeatureState& newState) {
     std::string sourceLayer = sourceLayerID.value_or(std::string());
     for (const auto& state : newState) {
         auto& layerStates = stateChanges[sourceLayer];
@@ -14,9 +15,11 @@ void SourceFeatureState::updateState(const optional<std::string>& sourceLayerID,
     }
 }
 
-void SourceFeatureState::getState(FeatureState& result, const optional<std::string>& sourceLayerID, const std::string& featureID) const {
+void SourceFeatureState::getState(FeatureState& result, const optional<std::string>& sourceLayerID,
+                                  const std::string& featureID) const {
     std::string sourceLayer = sourceLayerID.value_or(std::string());
-    FeatureState current, changes;
+    FeatureState current;
+    FeatureState changes;
     auto layerStates = currentStates.find(sourceLayer);
     if (layerStates != currentStates.end()) {
         const auto currentStateEntry = layerStates->second.find(featureID);
@@ -61,7 +64,7 @@ void SourceFeatureState::coalesceChanges(std::vector<RenderTile>& tiles) {
 
     for (const auto& layerStatesEntry : deletedStates) {
         const auto& sourceLayer = layerStatesEntry.first;
-        FeatureStates layerStates = { {}, {} };
+        FeatureStates layerStates = {{}, {}};
 
         if (deletedStates[sourceLayer].empty()) {
             for (const auto& featureStatesEntry : currentStates[sourceLayer]) {
@@ -89,25 +92,31 @@ void SourceFeatureState::coalesceChanges(std::vector<RenderTile>& tiles) {
     stateChanges.clear();
     deletedStates.clear();
 
-    if (changes.empty()) return;
+    if (changes.empty()) {
+        return;
+    }
 
     for (auto& tile : tiles) {
         tile.setFeatureState(changes);
     }
 }
 
-void SourceFeatureState::removeState(const optional<std::string>& sourceLayerID, const optional<std::string>& featureID, const optional<std::string>& stateKey) {
+void SourceFeatureState::removeState(const optional<std::string>& sourceLayerID, const optional<std::string>& featureID,
+                                     const optional<std::string>& stateKey) {
     std::string sourceLayer = sourceLayerID.value_or(std::string());
 
     bool sourceLayerDeleted = (deletedStates.count(sourceLayer) > 0) && deletedStates[sourceLayer].empty();
-    if (sourceLayerDeleted) return;
+    if (sourceLayerDeleted) {
+        return;
+    }
 
     if (stateKey && featureID) {
         if ((deletedStates.count(sourceLayer) == 0) && (deletedStates[sourceLayer].count(*featureID)) == 0) {
             deletedStates[sourceLayer][*featureID][*stateKey] = {};
         }
     } else if (featureID) {
-        bool updateInQueue = stateChanges.count(sourceLayer) && stateChanges[sourceLayer].count(*featureID);
+        bool updateInQueue =
+            (stateChanges.count(sourceLayer) != 0U) && (stateChanges[sourceLayer].count(*featureID) != 0U);
         if (updateInQueue) {
             for (const auto& changeEntry : stateChanges[sourceLayer][*featureID]) {
                 deletedStates[sourceLayer][*featureID][changeEntry.first] = {};
diff --git a/src/mbgl/renderer/source_state.hpp b/src/mbgl/renderer/source_state.hpp
index 61546aff62..7217302630 100644
--- a/src/mbgl/renderer/source_state.hpp
+++ b/src/mbgl/renderer/source_state.hpp
@@ -6,16 +6,17 @@
 namespace mbgl {
 
 class RenderTile;
-using namespace style::conversion;
 
 class SourceFeatureState {
 public:
     SourceFeatureState() = default;
     ~SourceFeatureState() = default;
 
-    void updateState(const optional<std::string>& sourceLayerID, const std::string& featureID, const FeatureState& newState);
+    void updateState(const optional<std::string>& sourceLayerID, const std::string& featureID,
+                     const FeatureState& newState);
     void getState(FeatureState& result, const optional<std::string>& sourceLayerID, const std::string& featureID) const;
-    void removeState(const optional<std::string>& sourceLayerID, const optional<std::string>& featureID, const optional<std::string>& stateKey);
+    void removeState(const optional<std::string>& sourceLayerID, const optional<std::string>& featureID,
+                     const optional<std::string>& stateKey);
 
     void coalesceChanges(std::vector<RenderTile>& tiles);
 
diff --git a/src/mbgl/renderer/sources/render_tile_source.cpp b/src/mbgl/renderer/sources/render_tile_source.cpp
index 3c6eff0855..221f976c50 100644
--- a/src/mbgl/renderer/sources/render_tile_source.cpp
+++ b/src/mbgl/renderer/sources/render_tile_source.cpp
@@ -134,14 +134,12 @@ std::vector<Feature> RenderTileSource::querySourceFeatures(const SourceQueryOpti
     return tilePyramid.querySourceFeatures(options);
 }
 
-void RenderTileSource::setFeatureState(const optional<std::string>& sourceLayerID,
-                                       const std::string& featureID,
+void RenderTileSource::setFeatureState(const optional<std::string>& sourceLayerID, const std::string& featureID,
                                        const FeatureState& state) {
     featureState.updateState(sourceLayerID, featureID, state);
 }
 
-void RenderTileSource::getFeatureState(FeatureState& state,
-                                       const optional<std::string>& sourceLayerID,
+void RenderTileSource::getFeatureState(FeatureState& state, const optional<std::string>& sourceLayerID,
                                        const std::string& featureID) const {
     featureState.getState(state, sourceLayerID, featureID);
 }
diff --git a/src/mbgl/renderer/sources/render_tile_source.hpp b/src/mbgl/renderer/sources/render_tile_source.hpp
index 48eea8558c..7756bd8ed0 100644
--- a/src/mbgl/renderer/sources/render_tile_source.hpp
+++ b/src/mbgl/renderer/sources/render_tile_source.hpp
@@ -1,9 +1,9 @@
 #pragma once
 
 #include <mbgl/renderer/render_source.hpp>
+#include <mbgl/renderer/source_state.hpp>
 #include <mbgl/renderer/tile_pyramid.hpp>
 #include <mbgl/style/sources/vector_source_impl.hpp>
-#include <mbgl/renderer/source_state.hpp>
 
 namespace mbgl {
 
@@ -35,17 +35,12 @@ public:
     std::vector<Feature>
     querySourceFeatures(const SourceQueryOptions&) const override;
 
-    virtual void setFeatureState(const optional<std::string>&,
-                         const std::string&,
-                         const FeatureState&) override;
+    void setFeatureState(const optional<std::string>&, const std::string&, const FeatureState&) override;
 
-    virtual void getFeatureState(FeatureState& state,
-                                 const optional<std::string>&,
-                                 const std::string&) const override;
+    void getFeatureState(FeatureState& state, const optional<std::string>&, const std::string&) const override;
 
-    virtual void removeFeatureState(const optional<std::string>&,
-                                    const optional<std::string>&,
-                                    const optional<std::string>&) override;
+    void removeFeatureState(const optional<std::string>&, const optional<std::string>&,
+                            const optional<std::string>&) override;
 
     void reduceMemoryUse() override;
     void dumpDebugLogs() const override;
@@ -56,7 +51,9 @@ protected:
     Immutable<std::vector<RenderTile>> renderTiles;
     mutable RenderTiles filteredRenderTiles;
     mutable RenderTiles renderTilesSortedByY;
-    float bearing = 0.0f;      
+
+private:
+    float bearing = 0.0F;
     SourceFeatureState featureState;
 };
 
diff --git a/src/mbgl/renderer/tile_pyramid.cpp b/src/mbgl/renderer/tile_pyramid.cpp
index db3e731605..2bf6e2e1a9 100644
--- a/src/mbgl/renderer/tile_pyramid.cpp
+++ b/src/mbgl/renderer/tile_pyramid.cpp
@@ -278,13 +278,10 @@ void TilePyramid::handleWrapJump(float lng) {
     }
 }
 
-
-std::unordered_map<std::string, std::vector<Feature>> TilePyramid::queryRenderedFeatures(const ScreenLineString& geometry,
-                                           const TransformState& transformState,
-                                           const std::unordered_map<std::string, const RenderLayer*>& layers,
-                                           const RenderedQueryOptions& options,
-                                           const mat4& projMatrix,
-                                           const SourceFeatureState& featureState) const {
+std::unordered_map<std::string, std::vector<Feature>> TilePyramid::queryRenderedFeatures(
+    const ScreenLineString& geometry, const TransformState& transformState,
+    const std::unordered_map<std::string, const RenderLayer*>& layers, const RenderedQueryOptions& options,
+    const mat4& projMatrix, const SourceFeatureState& featureState) const {
     std::unordered_map<std::string, std::vector<Feature>> result;
     if (renderedTiles.empty() || geometry.empty()) {
         return result;
@@ -332,12 +329,7 @@ std::unordered_map<std::string, std::vector<Feature>> TilePyramid::queryRendered
             tileSpaceQueryGeometry.push_back(TileCoordinate::toGeometryCoordinate(id, c));
         }
 
-        tile.queryRenderedFeatures(result,
-                                   tileSpaceQueryGeometry,
-                                   transformState,
-                                   layers,
-                                   options,
-                                   projMatrix,
+        tile.queryRenderedFeatures(result, tileSpaceQueryGeometry, transformState, layers, options, projMatrix,
                                    featureState);
     }
 
diff --git a/src/mbgl/renderer/tile_pyramid.hpp b/src/mbgl/renderer/tile_pyramid.hpp
index bb0b7e9f67..3b5cab5d6c 100644
--- a/src/mbgl/renderer/tile_pyramid.hpp
+++ b/src/mbgl/renderer/tile_pyramid.hpp
@@ -49,13 +49,10 @@ public:
 
     void handleWrapJump(float lng);
 
-    std::unordered_map<std::string, std::vector<Feature>>
-    queryRenderedFeatures(const ScreenLineString& geometry,
-                          const TransformState& transformState,
-                          const std::unordered_map<std::string, const RenderLayer*>&,
-                          const RenderedQueryOptions& options,
-                          const mat4& projMatrix,
-                          const mbgl::SourceFeatureState& featureState) const;
+    std::unordered_map<std::string, std::vector<Feature>> queryRenderedFeatures(
+        const ScreenLineString& geometry, const TransformState& transformState,
+        const std::unordered_map<std::string, const RenderLayer*>&, const RenderedQueryOptions& options,
+        const mat4& projMatrix, const mbgl::SourceFeatureState& featureState) const;
 
     std::vector<Feature> querySourceFeatures(const SourceQueryOptions&) const;
 
diff --git a/src/mbgl/style/expression/compound_expression.cpp b/src/mbgl/style/expression/compound_expression.cpp
index 8bd21bdad7..c2bc511e41 100644
--- a/src/mbgl/style/expression/compound_expression.cpp
+++ b/src/mbgl/style/expression/compound_expression.cpp
@@ -676,16 +676,17 @@ const auto& errorCompoundExpression() {
 }
 
 const auto& featureStateCompoundExpression() {
-    static auto signature = detail::makeSignature("feature-state", [](const EvaluationContext& params, const std::string& key) -> Result<Value> {
-        mbgl::Value state;
-        if (params.featureState) {
-            auto it = params.featureState->find(key);
-            if (it != params.featureState->end()) {
-                state = mbgl::Value(it->second);
+    static auto signature = detail::makeSignature(
+        "feature-state", [](const EvaluationContext& params, const std::string& key) -> Result<Value> {
+            mbgl::Value state;
+            if (params.featureState != nullptr) {
+                auto it = params.featureState->find(key);
+                if (it != params.featureState->end()) {
+                    state = mbgl::Value(it->second);
+                }
             }
-        }
-        return toExpressionValue(state);
-    });
+            return toExpressionValue(state);
+        });
     return signature;
 }
 
@@ -886,82 +887,83 @@ const auto& filterInCompoundExpression() {
 }
 
 using ParseCompoundFunction = const std::unique_ptr<detail::SignatureBase>& (*)();
-MAPBOX_ETERNAL_CONSTEXPR const auto compoundExpressionRegistry = mapbox::eternal::hash_map<mapbox::eternal::string, ParseCompoundFunction>({
-    { "e", eCompoundExpression },
-    { "pi", piCompoundExpression },
-    { "ln2", ln2CompoundExpression },
-    { "typeof", typeofCompoundExpression },
-    { "to-rgba", toRgbaCompoundExpression },
-    { "rgba", rgbaCompoundExpression },
-    { "rgb", rgbCompoundExpression },
-    { "zoom", zoomCompoundExpression },
-    { "heatmap-density", heatmapDensityCompoundExpression },
-    { "line-progress", lineProgressCompoundExpression },
-    { "accumulated", accumulatedCompoundExpression },
-    { "has", hasContextCompoundExpression },
-    { "has", hasObjectCompoundExpression },
-    { "get", getContextCompoundExpression },
-    { "get", getObjectCompoundExpression },
-    { "properties", propertiesCompoundExpression },
-    { "geometry-type", geometryTypeCompoundExpression },
-    { "id", idCompoundExpression },
-    { "+", plusCompoundExpression },
-    { "-", minusCompoundExpression },
-    { "-", negateCompoundExpression },
-    { "*", multiplyCompoundExpression },
-    { "/", divideCompoundExpression },
-    { "%", modCompoundExpression },
-    { "^", powCompoundExpression },
-    { "sqrt", sqrtCompoundExpression },
-    { "log10", log10CompoundExpression },
-    { "ln", lnCompoundExpression },
-    { "log2", log2CompoundExpression },
-    { "sin", sinCompoundExpression },
-    { "cos", cosCompoundExpression },
-    { "tan", tanCompoundExpression },
-    { "asin", asinCompoundExpression },
-    { "acos", acosCompoundExpression },
-    { "atan", atanCompoundExpression },
-    { "min", minCompoundExpression },
-    { "max", maxCompoundExpression },
-    { "round", roundCompoundExpression },
-    { "floor", floorCompoundExpression },
-    { "ceil", ceilCompoundExpression },
-    { "abs", absCompoundExpression },
-    { "!", notCompoundExpression },
-    { "is-supported-script", isSupportedScriptCompoundExpression },
-    { "upcase", upcaseCompoundExpression },
-    { "downcase", downcaseCompoundExpression },
-    { "concat", concatCompoundExpression },
-    { "resolved-locale", resolvedLocaleCompoundExpression },
-    { "error", errorCompoundExpression },
-    { "feature-state", featureStateCompoundExpression },
-    // Legacy Filters
-    { "filter-==", filterEqualsCompoundExpression },
-    { "filter-id-==", filterIdEqualsCompoundExpression },
-    { "filter-type-==", filterTypeEqualsCompoundExpression },
-    { "filter-<", filterLessThanNumberCompoundExpression },
-    { "filter-<", filterLessThanStringCompoundExpression },
-    { "filter-id-<", filterIdLessThanNumberCompoundExpression },
-    { "filter-id-<", filterIdLessThanStringCompoundExpression },
-    { "filter->", filterMoreThanNumberCompoundExpression },
-    { "filter->", filterMoreThanStringCompoundExpression },
-    { "filter-id->", filterIdMoreThanNumberCompoundExpression },
-    { "filter-id->", filterIdMoreThanStringCompoundExpression },
-    { "filter-<=", filterLessOrEqualThanNumberCompoundExpression },
-    { "filter-<=", filterLessOrEqualThanStringCompoundExpression },
-    { "filter-id-<=", filterIdLessOrEqualThanNumberCompoundExpression },
-    { "filter-id-<=", filterIdLessOrEqualThanStringCompoundExpression },
-    { "filter->=", filterGreaterOrEqualThanNumberCompoundExpression },
-    { "filter->=", filterGreaterOrEqualThanStringCompoundExpression },
-    { "filter-id->=", filterIdGreaterOrEqualThanNumberCompoundExpression },
-    { "filter-id->=", filterIdGreaterOrEqualThanStringCompoundExpression },
-    { "filter-has", filterHasCompoundExpression },
-    { "filter-has-id", filterHasIdCompoundExpression },
-    { "filter-type-in", filterTypeInCompoundExpression },
-    { "filter-id-in", filterIdInCompoundExpression },
-    { "filter-in", filterInCompoundExpression },
-});
+MAPBOX_ETERNAL_CONSTEXPR const auto compoundExpressionRegistry =
+    mapbox::eternal::hash_map<mapbox::eternal::string, ParseCompoundFunction>({
+        {"e", eCompoundExpression},
+        {"pi", piCompoundExpression},
+        {"ln2", ln2CompoundExpression},
+        {"typeof", typeofCompoundExpression},
+        {"to-rgba", toRgbaCompoundExpression},
+        {"rgba", rgbaCompoundExpression},
+        {"rgb", rgbCompoundExpression},
+        {"zoom", zoomCompoundExpression},
+        {"heatmap-density", heatmapDensityCompoundExpression},
+        {"line-progress", lineProgressCompoundExpression},
+        {"accumulated", accumulatedCompoundExpression},
+        {"has", hasContextCompoundExpression},
+        {"has", hasObjectCompoundExpression},
+        {"get", getContextCompoundExpression},
+        {"get", getObjectCompoundExpression},
+        {"properties", propertiesCompoundExpression},
+        {"geometry-type", geometryTypeCompoundExpression},
+        {"id", idCompoundExpression},
+        {"+", plusCompoundExpression},
+        {"-", minusCompoundExpression},
+        {"-", negateCompoundExpression},
+        {"*", multiplyCompoundExpression},
+        {"/", divideCompoundExpression},
+        {"%", modCompoundExpression},
+        {"^", powCompoundExpression},
+        {"sqrt", sqrtCompoundExpression},
+        {"log10", log10CompoundExpression},
+        {"ln", lnCompoundExpression},
+        {"log2", log2CompoundExpression},
+        {"sin", sinCompoundExpression},
+        {"cos", cosCompoundExpression},
+        {"tan", tanCompoundExpression},
+        {"asin", asinCompoundExpression},
+        {"acos", acosCompoundExpression},
+        {"atan", atanCompoundExpression},
+        {"min", minCompoundExpression},
+        {"max", maxCompoundExpression},
+        {"round", roundCompoundExpression},
+        {"floor", floorCompoundExpression},
+        {"ceil", ceilCompoundExpression},
+        {"abs", absCompoundExpression},
+        {"!", notCompoundExpression},
+        {"is-supported-script", isSupportedScriptCompoundExpression},
+        {"upcase", upcaseCompoundExpression},
+        {"downcase", downcaseCompoundExpression},
+        {"concat", concatCompoundExpression},
+        {"resolved-locale", resolvedLocaleCompoundExpression},
+        {"error", errorCompoundExpression},
+        {"feature-state", featureStateCompoundExpression},
+        // Legacy Filters
+        {"filter-==", filterEqualsCompoundExpression},
+        {"filter-id-==", filterIdEqualsCompoundExpression},
+        {"filter-type-==", filterTypeEqualsCompoundExpression},
+        {"filter-<", filterLessThanNumberCompoundExpression},
+        {"filter-<", filterLessThanStringCompoundExpression},
+        {"filter-id-<", filterIdLessThanNumberCompoundExpression},
+        {"filter-id-<", filterIdLessThanStringCompoundExpression},
+        {"filter->", filterMoreThanNumberCompoundExpression},
+        {"filter->", filterMoreThanStringCompoundExpression},
+        {"filter-id->", filterIdMoreThanNumberCompoundExpression},
+        {"filter-id->", filterIdMoreThanStringCompoundExpression},
+        {"filter-<=", filterLessOrEqualThanNumberCompoundExpression},
+        {"filter-<=", filterLessOrEqualThanStringCompoundExpression},
+        {"filter-id-<=", filterIdLessOrEqualThanNumberCompoundExpression},
+        {"filter-id-<=", filterIdLessOrEqualThanStringCompoundExpression},
+        {"filter->=", filterGreaterOrEqualThanNumberCompoundExpression},
+        {"filter->=", filterGreaterOrEqualThanStringCompoundExpression},
+        {"filter-id->=", filterIdGreaterOrEqualThanNumberCompoundExpression},
+        {"filter-id->=", filterIdGreaterOrEqualThanStringCompoundExpression},
+        {"filter-has", filterHasCompoundExpression},
+        {"filter-has-id", filterHasIdCompoundExpression},
+        {"filter-type-in", filterTypeInCompoundExpression},
+        {"filter-id-in", filterIdInCompoundExpression},
+        {"filter-in", filterInCompoundExpression},
+    });
 
 using namespace mbgl::style::conversion;
 
diff --git a/src/mbgl/style/expression/is_constant.cpp b/src/mbgl/style/expression/is_constant.cpp
index 5f8215c55f..4c4684c86a 100644
--- a/src/mbgl/style/expression/is_constant.cpp
+++ b/src/mbgl/style/expression/is_constant.cpp
@@ -17,12 +17,7 @@ bool isFeatureConstant(const Expression& expression) {
             return false;
         } else if (name == "has" && parameterCount && *parameterCount == 1) {
             return false;
-        } else if (
-            name == "properties" ||
-            name == "geometry-type" ||
-            name == "id" ||
-            name == "feature-state"
-        ) {
+        } else if (name == "properties" || name == "geometry-type" || name == "id" || name == "feature-state") {
             return false;
         } else if (0u == name.rfind(filter, 0u)) {
             // Legacy filters begin with "filter-" and are never constant.
diff --git a/src/mbgl/style/properties.hpp b/src/mbgl/style/properties.hpp
index b07456a96d..db0e54330c 100644
--- a/src/mbgl/style/properties.hpp
+++ b/src/mbgl/style/properties.hpp
@@ -183,13 +183,8 @@ public:
         template <class T>
         static T evaluate(float z, const GeometryTileFeature& feature, const FeatureState& state,
                           const PossiblyEvaluatedPropertyValue<T>& v, const T& defaultValue) {
-            return v.match(
-                [&] (const T& t) {
-                    return t;
-                },
-                [&] (const PropertyExpression<T>& t) {
-                    return t.evaluate(z, feature, state, defaultValue);
-                });
+            return v.match([&](const T& t) { return t; },
+                           [&](const PropertyExpression<T>& t) { return t.evaluate(z, feature, state, defaultValue); });
         }
 
         template <class P>
diff --git a/src/mbgl/tile/geometry_tile.cpp b/src/mbgl/tile/geometry_tile.cpp
index 2076c73337..9f9c41d229 100644
--- a/src/mbgl/tile/geometry_tile.cpp
+++ b/src/mbgl/tile/geometry_tile.cpp
@@ -302,15 +302,11 @@ float GeometryTile::getQueryPadding(const std::unordered_map<std::string, const
     return queryPadding;
 }
 
-void GeometryTile::queryRenderedFeatures(
-    std::unordered_map<std::string, std::vector<Feature>>& result,
-    const GeometryCoordinates& queryGeometry,
-    const TransformState& transformState,
-    const std::unordered_map<std::string, const RenderLayer*>& layers,
-    const RenderedQueryOptions& options,
-    const mat4& projMatrix,
-    const SourceFeatureState& featureState) {
-
+void GeometryTile::queryRenderedFeatures(std::unordered_map<std::string, std::vector<Feature>>& result,
+                                         const GeometryCoordinates& queryGeometry, const TransformState& transformState,
+                                         const std::unordered_map<std::string, const RenderLayer*>& layers,
+                                         const RenderedQueryOptions& options, const mat4& projMatrix,
+                                         const SourceFeatureState& featureState) {
     if (!getData()) return;
 
     const float queryPadding = getQueryPadding(layers);
@@ -319,17 +315,10 @@ void GeometryTile::queryRenderedFeatures(
     transformState.matrixFor(posMatrix, id.toUnwrapped());
     matrix::multiply(posMatrix, projMatrix, posMatrix);
 
-    layoutResult->featureIndex->query(result,
-                              queryGeometry,
-                              transformState,
-                              posMatrix,
-                              util::tileSize * id.overscaleFactor(),
-                              std::pow(2, transformState.getZoom() - id.overscaledZ),
-                              options,
-                              id.toUnwrapped(),
-                              layers,
-                              queryPadding * transformState.maxPitchScaleFactor(),
-                              featureState);
+    layoutResult->featureIndex->query(result, queryGeometry, transformState, posMatrix,
+                                      util::tileSize * id.overscaleFactor(),
+                                      std::pow(2, transformState.getZoom() - id.overscaledZ), options, id.toUnwrapped(),
+                                      layers, queryPadding * transformState.maxPitchScaleFactor(), featureState);
 }
 
 void GeometryTile::querySourceFeatures(
@@ -391,7 +380,9 @@ void GeometryTile::performedFadePlacement() {
 
 void GeometryTile::setFeatureState(const LayerFeatureStates& states) {
     auto layers = getData();
-    if (!layers || states.empty() || !layoutResult) return;
+    if ((layers == nullptr) || states.empty() || !layoutResult) {
+        return;
+    }
 
     auto& layerIdToLayerRenderData = layoutResult->layerRenderData;
     for (auto& layer : layerIdToLayerRenderData) {
@@ -400,9 +391,13 @@ void GeometryTile::setFeatureState(const LayerFeatureStates& states) {
         if (sourceLayer) {
             const auto& sourceLayerID = sourceLayer->getName();
             auto entry = states.find(sourceLayerID);
-            if (entry == states.end()) continue;
+            if (entry == states.end()) {
+                continue;
+            }
             const auto& featureStates = entry->second;
-            if (featureStates.empty()) continue;
+            if (featureStates.empty()) {
+                continue;
+            }
 
             auto bucket = layer.second.bucket;
             if (bucket && bucket->hasData()) {
diff --git a/src/mbgl/tile/geometry_tile.hpp b/src/mbgl/tile/geometry_tile.hpp
index 4415e0a1fa..566b359547 100644
--- a/src/mbgl/tile/geometry_tile.hpp
+++ b/src/mbgl/tile/geometry_tile.hpp
@@ -48,14 +48,11 @@ public:
 
     bool layerPropertiesUpdated(const Immutable<style::LayerProperties>&) override;
 
-    void queryRenderedFeatures(
-            std::unordered_map<std::string, std::vector<Feature>>& result,
-            const GeometryCoordinates& queryGeometry,
-            const TransformState&,
-            const std::unordered_map<std::string, const RenderLayer*>& layers,
-            const RenderedQueryOptions& options,
-            const mat4& projMatrix,
-            const SourceFeatureState& featureState) override;
+    void queryRenderedFeatures(std::unordered_map<std::string, std::vector<Feature>>& result,
+                               const GeometryCoordinates& queryGeometry, const TransformState&,
+                               const std::unordered_map<std::string, const RenderLayer*>& layers,
+                               const RenderedQueryOptions& options, const mat4& projMatrix,
+                               const SourceFeatureState& featureState) override;
 
     void querySourceFeatures(
         std::vector<Feature>& result,
@@ -94,7 +91,7 @@ public:
     const std::shared_ptr<FeatureIndex> getFeatureIndex() const;
     
     const std::string sourceID;
-    
+
     void setFeatureState(const LayerFeatureStates&) override;
 
 protected:
diff --git a/src/mbgl/tile/geometry_tile_worker.cpp b/src/mbgl/tile/geometry_tile_worker.cpp
index ce883ad93f..f6af61eb3c 100644
--- a/src/mbgl/tile/geometry_tile_worker.cpp
+++ b/src/mbgl/tile/geometry_tile_worker.cpp
@@ -384,7 +384,7 @@ void GeometryTileWorker::parse() {
                     continue;
 
                 const GeometryCollection& geometries = feature->getGeometries();
-                bucket->addFeature(*feature, geometries, {}, PatternLayerMap (), i);
+                bucket->addFeature(*feature, geometries, {}, PatternLayerMap(), i);
                 featureIndex->insert(geometries, i, sourceLayerID, leaderImpl.id);
             }
 
diff --git a/src/mbgl/tile/tile.cpp b/src/mbgl/tile/tile.cpp
index 87223c7933..2ebbf76c2a 100644
--- a/src/mbgl/tile/tile.cpp
+++ b/src/mbgl/tile/tile.cpp
@@ -39,14 +39,9 @@ void Tile::dumpDebugLogs() const {
     Log::Info(Event::General, "Tile::complete: %s", isComplete() ? "yes" : "no");
 }
 
-void Tile::queryRenderedFeatures(
-        std::unordered_map<std::string, std::vector<Feature>>&,
-        const GeometryCoordinates&,
-        const TransformState&,
-        const std::unordered_map<std::string, const RenderLayer*>&,
-        const RenderedQueryOptions&,
-        const mat4&,
-        const SourceFeatureState&) {}
+void Tile::queryRenderedFeatures(std::unordered_map<std::string, std::vector<Feature>>&, const GeometryCoordinates&,
+                                 const TransformState&, const std::unordered_map<std::string, const RenderLayer*>&,
+                                 const RenderedQueryOptions&, const mat4&, const SourceFeatureState&) {}
 
 float Tile::getQueryPadding(const std::unordered_map<std::string, const RenderLayer*>&) {
     return 0;
diff --git a/src/mbgl/tile/tile.hpp b/src/mbgl/tile/tile.hpp
index eda4667027..b73383f989 100644
--- a/src/mbgl/tile/tile.hpp
+++ b/src/mbgl/tile/tile.hpp
@@ -68,14 +68,11 @@ public:
     virtual void setLayers(const std::vector<Immutable<style::LayerProperties>>&) {}
     virtual void setMask(TileMask&&) {}
 
-    virtual void queryRenderedFeatures(
-            std::unordered_map<std::string, std::vector<Feature>>& result,
-            const GeometryCoordinates& queryGeometry,
-            const TransformState&,
-            const std::unordered_map<std::string, const RenderLayer*>&,
-            const RenderedQueryOptions& options,
-            const mat4& projMatrix,
-            const SourceFeatureState& featureState);
+    virtual void queryRenderedFeatures(std::unordered_map<std::string, std::vector<Feature>>& result,
+                                       const GeometryCoordinates& queryGeometry, const TransformState&,
+                                       const std::unordered_map<std::string, const RenderLayer*>&,
+                                       const RenderedQueryOptions& options, const mat4& projMatrix,
+                                       const SourceFeatureState& featureState);
 
     virtual void querySourceFeatures(
             std::vector<Feature>& result,
diff --git a/test/gl/bucket.test.cpp b/test/gl/bucket.test.cpp
index 55d05809fa..13b30eb75d 100644
--- a/test/gl/bucket.test.cpp
+++ b/test/gl/bucket.test.cpp
@@ -52,7 +52,8 @@ TEST(Buckets, CircleBucket) {
     ASSERT_FALSE(bucket.needsUpload());
 
     GeometryCollection point { { { 0, 0 } } };
-    bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Point, point, properties }, point, {}, PatternLayerMap(), 0);
+    bucket.addFeature(StubGeometryTileFeature{{}, FeatureType::Point, point, properties}, point, {}, PatternLayerMap(),
+                      0);
     ASSERT_TRUE(bucket.hasData());
     ASSERT_TRUE(bucket.needsUpload());
 
@@ -74,7 +75,8 @@ TEST(Buckets, FillBucket) {
     ASSERT_FALSE(bucket.needsUpload());
 
     GeometryCollection polygon { { { 0, 0 }, { 0, 1 }, { 1, 1 } } };
-    bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Polygon, polygon, properties }, polygon, {}, PatternLayerMap(), 0);
+    bucket.addFeature(StubGeometryTileFeature{{}, FeatureType::Polygon, polygon, properties}, polygon, {},
+                      PatternLayerMap(), 0);
     ASSERT_TRUE(bucket.hasData());
     ASSERT_TRUE(bucket.needsUpload());
 
@@ -96,11 +98,13 @@ TEST(Buckets, LineBucket) {
 
     // Ignore invalid feature type.
     GeometryCollection point { { { 0, 0 } } };
-    bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Point, point, properties }, point, {}, PatternLayerMap(), 0);
+    bucket.addFeature(StubGeometryTileFeature{{}, FeatureType::Point, point, properties}, point, {}, PatternLayerMap(),
+                      0);
     ASSERT_FALSE(bucket.hasData());
 
     GeometryCollection line { { { 0, 0 }, { 1, 1 } } };
-    bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::LineString, line, properties }, line, {}, PatternLayerMap(), 1);
+    bucket.addFeature(StubGeometryTileFeature{{}, FeatureType::LineString, line, properties}, line, {},
+                      PatternLayerMap(), 1);
     ASSERT_TRUE(bucket.hasData());
     ASSERT_TRUE(bucket.needsUpload());
 
@@ -134,7 +138,8 @@ TEST(Buckets, SymbolBucket) {
 
     // SymbolBucket::addFeature() is a no-op.
     GeometryCollection point { { { 0, 0 } } };
-    bucket.addFeature(StubGeometryTileFeature { {}, FeatureType::Point, std::move(point), properties }, point, {}, PatternLayerMap(), 0);
+    bucket.addFeature(StubGeometryTileFeature{{}, FeatureType::Point, std::move(point), properties}, point, {},
+                      PatternLayerMap(), 0);
     ASSERT_FALSE(bucket.hasData());
     ASSERT_FALSE(bucket.needsUpload());