1 files changed, 26 insertions, 17 deletions
diff --git a/src/mbgl/style/parser.cpp b/src/mbgl/style/parser.cpp
index a83897dbf5..8d14d7972c 100644
--- a/src/mbgl/style/parser.cpp
+++ b/src/mbgl/style/parser.cpp
@@ -1,11 +1,13 @@
 #include <mbgl/style/parser.hpp>
 #include <mbgl/style/layer_impl.hpp>
+#include <mbgl/style/layers/symbol_layer.hpp>
 #include <mbgl/style/rapidjson_conversion.hpp>
 #include <mbgl/style/conversion.hpp>
 #include <mbgl/style/conversion/coordinate.hpp>
 #include <mbgl/style/conversion/source.hpp>
 #include <mbgl/style/conversion/layer.hpp>
 #include <mbgl/style/conversion/light.hpp>
+#include <mbgl/style/conversion/transition_options.hpp>
 
 #include <mbgl/util/logging.hpp>
 #include <mbgl/util/string.hpp>
@@ -117,6 +119,9 @@ StyleParseResult Parser::parse(const std::string& json) {
         }
     }
 
+    // Call for side effect of logging warnings for invalid values.
+    fontStacks();
+
     return nullptr;
 }
 
@@ -149,7 +154,7 @@ void Parser::parseSources(const JSValue& value) {
     }
 
     for (const auto& property : value.GetObject()) {
-        std::string id = *conversion::toString(property.name);
+        std::string id { property.name.GetString(), property.name.GetStringLength() };
 
         conversion::Error error;
         optional<std::unique_ptr<Source>> source =
@@ -256,7 +261,7 @@ void Parser::parseLayer(const std::string& id, const JSValue& value, std::unique
         }
 
         layer = reference->cloneRef(id);
-        conversion::setPaintProperties(*layer, value);
+        conversion::setPaintProperties(*layer, conversion::Convertible(&value));
     } else {
         conversion::Error error;
         optional<std::unique_ptr<Layer>> converted = conversion::convert<std::unique_ptr<Layer>>(value, error);
@@ -269,28 +274,32 @@ void Parser::parseLayer(const std::string& id, const JSValue& value, std::unique
 }
 
 std::vector<FontStack> Parser::fontStacks() const {
-    std::set<FontStack> optional;
+    std::set<FontStack> result;
 
     for (const auto& layer : layers) {
-        if (layer->is<SymbolLayer>()) {
-            PropertyValue<FontStack> textFont = layer->as<SymbolLayer>()->getTextFont();
-            if (textFont.isUndefined()) {
-                optional.insert({"Open Sans Regular", "Arial Unicode MS Regular"});
-            } else if (textFont.isConstant()) {
-                optional.insert(textFont.asConstant());
-            } else if (textFont.isCameraFunction()) {
-                textFont.asCameraFunction().stops.match(
-                    [&] (const auto& stops) {
-                        for (const auto& stop : stops.stops) {
-                            optional.insert(stop.second);
+        if (layer->is<SymbolLayer>() && !layer->as<SymbolLayer>()->getTextField().isUndefined()) {
+            layer->as<SymbolLayer>()->getTextFont().match(
+                [&] (Undefined) {
+                    result.insert({"Open Sans Regular", "Arial Unicode MS Regular"});
+                },
+                [&] (const FontStack& constant) {
+                    result.insert(constant);
+                },
+                [&] (const auto& function) {
+                    for (const auto& value : function.possibleOutputs()) {
+                        if (value) {
+                            result.insert(*value);
+                        } else {
+                            Log::Warning(Event::ParseStyle, "Layer '%s' has an invalid value for text-font and will not work offline. Output values must be contained as literals within the expression.", layer->getID().c_str());
+                            break;
                         }
                     }
-                );
-            }
+                }
+            );
         }
     }
 
-    return std::vector<FontStack>(optional.begin(), optional.end());
+    return std::vector<FontStack>(result.begin(), result.end());
 }
 
 } // namespace style