1 files changed, 30 insertions, 30 deletions

diff --git a/src/mbgl/style/conversion/filter.cpp b/src/mbgl/style/conversion/filter.cpp
index b690c96388..5114c61778 100644
--- a/src/mbgl/style/conversion/filter.cpp
+++ b/src/mbgl/style/conversion/filter.cpp
@@ -9,9 +9,9 @@
 namespace mbgl {
 namespace style {
 namespace conversion {
-    
+
 using namespace mbgl::style::expression;
-    
+
 static bool isExpression(const Convertible& filter);
 ParseResult convertLegacyFilter(const Convertible& values, Error& error);
 optional<mbgl::Value> serializeLegacyFilter(const Convertible& values);
@@ -21,8 +21,8 @@ optional<Filter> Converter<Filter>::operator()(const Convertible& value, Error&
         ParsingContext parsingContext(type::Boolean);
         ParseResult parseResult = parsingContext.parseExpression(value);
         if (!parseResult) {
-            error = { parsingContext.getCombinedErrors() };
-            return {};
+            error.message = parsingContext.getCombinedErrors();
+            return nullopt;
         } else {
             return { Filter(std::move(parseResult)) };
         }
@@ -30,7 +30,7 @@ optional<Filter> Converter<Filter>::operator()(const Convertible& value, Error&
         ParseResult expression = convertLegacyFilter(value, error);
         if (!expression) {
             assert(error.message.size() > 0);
-            return {};
+            return nullopt;
         }
         return Filter(optional<std::unique_ptr<Expression>>(std::move(*expression)), serializeLegacyFilter(value));
     }
@@ -41,23 +41,23 @@ bool isExpression(const Convertible& filter) {
     if (!isArray(filter) || arrayLength(filter) == 0) {
         return false;
     }
-    
+
     optional<std::string> op = toString(arrayMember(filter, 0));
-    
+
     if (!op) {
         return false;
-        
+
     } else if (*op == "has") {
         if (arrayLength(filter) < 2) return false;
         optional<std::string> operand = toString(arrayMember(filter, 1));
         return operand && *operand != "$id" && *operand != "$type";
-        
+
     } else if (*op == "in" || *op == "!in" || *op == "!has" || *op == "none") {
         return false;
-        
+
     } else if (*op == "==" || *op == "!=" || *op == ">" || *op == ">=" || *op == "<" || *op == "<=") {
         return arrayLength(filter) != 3 || isArray(arrayMember(filter, 1)) || isArray(arrayMember(filter, 2));
-        
+
     } else if (*op == "any" || *op == "all") {
         for (std::size_t i = 1; i < arrayLength(filter); i++) {
             Convertible f = arrayMember(filter, i);
@@ -66,18 +66,18 @@ bool isExpression(const Convertible& filter) {
             }
         }
         return true;
-        
+
     } else {
         return true;
     }
 }
-    
+
 ParseResult createExpression(std::string op, optional<std::vector<std::unique_ptr<Expression>>> args, Error& error) {
     if (!args) return {};
     assert(std::all_of(args->begin(), args->end(), [](const std::unique_ptr<Expression> &e) {
         return bool(e.get());
     }));
-    
+
     if (op == "any") {
         return {std::make_unique<Any>(std::move(*args))};
     } else if (op == "all") {
@@ -86,7 +86,7 @@ ParseResult createExpression(std::string op, optional<std::vector<std::unique_pt
         ParsingContext parsingContext(type::Boolean);
         ParseResult parseResult = createCompoundExpression(op, std::move(*args), parsingContext);
         if (!parseResult) {
-            error = { parsingContext.getCombinedErrors() };
+            error.message = parsingContext.getCombinedErrors();
             return {};
         } else {
             return parseResult;
@@ -98,7 +98,7 @@ ParseResult createExpression(std::string op, ParseResult arg, Error& error) {
     if (!arg) {
         return {};
     }
-    
+
     std::vector<std::unique_ptr<Expression>> args;
     args.push_back(std::move(*arg));
     return createExpression(op, std::move(args), error);
@@ -110,7 +110,7 @@ ParseResult convertLiteral(const Convertible& convertible, Error& error) {
     if (parseResult) {
         return parseResult;
     } else {
-        error = { parsingContext.getCombinedErrors() };
+        error.message = parsingContext.getCombinedErrors();
         return {};
     }
 }
@@ -120,7 +120,7 @@ optional<std::vector<std::unique_ptr<Expression>>> convertLiteralArray(const Con
     for (std::size_t i = startIndex; i < arrayLength(input); i++) {
         ParseResult literal = convertLiteral(arrayMember(input, i), error);
         if (!literal) {
-            return {};
+            return nullopt;
         }
         output.push_back(std::move(*literal));
     }
@@ -130,9 +130,9 @@ optional<std::vector<std::unique_ptr<Expression>>> convertLiteralArray(const Con
 ParseResult convertLegacyComparisonFilter(const Convertible& values, Error& error, optional<std::string> opOverride = {}) {
     optional<std::string> op = opOverride ? opOverride : toString(arrayMember(values, 0));
     optional<std::string> property = toString(arrayMember(values, 1));
-    
+
     if (!property) {
-        error = { "filter property must be a string" };
+        error.message = "filter property must be a string";
         return {};
     } else if (*property == "$type") {
         return createExpression("filter-type-" + *op, convertLiteralArray(values, error, 2), error);
@@ -142,12 +142,12 @@ ParseResult convertLegacyComparisonFilter(const Convertible& values, Error& erro
         return createExpression("filter-" + *op, convertLiteralArray(values, error, 1), error);
     }
 }
-    
+
 ParseResult convertLegacyHasFilter(const Convertible& values, Error& error) {
     optional<std::string> property = toString(arrayMember(values, 1));
-    
+
     if (!property) {
-        error = { "filter property must be a string" };
+        error.message = "filter property must be a string";
         return {};
     } else if (*property == "$type") {
         return {std::make_unique<Literal>(true)};
@@ -160,9 +160,9 @@ ParseResult convertLegacyHasFilter(const Convertible& values, Error& error) {
 
 ParseResult convertLegacyInFilter(const Convertible& values, Error& error) {
     optional<std::string> property = toString(arrayMember(values, 1));
-    
+
     if (!property) {
-        error = { "filter property must be a string" };
+        error.message = "filter property must be a string";
         return {};
     } else if (arrayLength(values) == 0) {
         return {std::make_unique<Literal>(false)};
@@ -180,22 +180,22 @@ optional<std::vector<std::unique_ptr<Expression>>> convertLegacyFilterArray(cons
     for (std::size_t i = startIndex; i < arrayLength(input); i++) {
         optional<std::unique_ptr<Expression>> child = convertLegacyFilter(arrayMember(input, i), error);
         if (!child) {
-            return {};
+            return nullopt;
         }
         output.push_back(std::move(*child));
     }
     return {std::move(output)};
 }
-    
+
 ParseResult convertLegacyFilter(const Convertible& values, Error& error) {
     if (isUndefined(values)) {
         return {std::make_unique<Literal>(true)};
     }
-    
+
     optional<std::string> op = toString(arrayMember(values, 0));
 
     if (!op) {
-        error = { "filter operator must be a string" };
+        error.message = "filter operator must be a string";
         return {};
     } else if (arrayLength(values) <= 1) {
         return {std::make_unique<Literal>(*op != "any")};
@@ -221,7 +221,7 @@ ParseResult convertLegacyFilter(const Convertible& values, Error& error) {
 
 optional<mbgl::Value> serializeLegacyFilter(const Convertible& values) {
     if (isUndefined(values)) {
-        return {};
+        return nullopt;
     } else if (isArray(values)) {
         std::vector<mbgl::Value> result;
         for (std::size_t i = 0; i < arrayLength(values); i++) {