sassc 2.1.0.pre3 → 2.4.0

data/ext/libsass/src/fn_colors.cpp

@@ -2,12 +2,12 @@
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
-#include <cctype>
 #include <iomanip>
 #include "ast.hpp"
 #include "fn_utils.hpp"
 #include "fn_colors.hpp"
 #include "util.hpp"
+#include "util_string.hpp"
 
 namespace Sass {
 
@@ -16,16 +16,16 @@ namespace Sass {
     bool string_argument(AST_Node_Obj obj) {
       String_Constant* s = Cast<String_Constant>(obj);
       if (s == nullptr) return false;
-      const std::string& str = s->value();
+      const sass::string& str = s->value();
       return starts_with(str, "calc(") ||
              starts_with(str, "var(");
     }
 
-    void hsla_alpha_percent_deprecation(const ParserState& pstate, const std::string val)
+    void hsla_alpha_percent_deprecation(const SourceSpan& pstate, const sass::string val)
     {
 
-      std::string msg("Passing a percentage as the alpha value to hsla() will be interpreted");
-      std::string tail("differently in future versions of Sass. For now, use " + val + " instead.");
+      sass::string msg("Passing a percentage as the alpha value to hsla() will be interpreted");
+      sass::string tail("differently in future versions of Sass. For now, use " + val + " instead.");
 
       deprecated(msg, tail, false, pstate);
 
@@ -104,7 +104,7 @@ namespace Sass {
       if (
         string_argument(env["$alpha"])
       ) {
-        std::stringstream strm;
+        sass::ostream strm;
         strm << "rgba("
                  << (int)c_arg->r() << ", "
                  << (int)c_arg->g() << ", "
@@ -145,7 +145,7 @@ namespace Sass {
       return SASS_MEMORY_NEW(Number, pstate, color->b());
     }
 
-    Color_RGBA* colormix(Context& ctx, ParserState& pstate, Color* color1, Color* color2, double weight) {
+    Color_RGBA* colormix(Context& ctx, SourceSpan& pstate, Color* color1, Color* color2, double weight) {
       Color_RGBA_Obj c1 = color1->toRGBA();
       Color_RGBA_Obj c2 = color2->toRGBA();
       double p = weight/100;
@@ -163,11 +163,11 @@ namespace Sass {
                              c1->a()*p + c2->a()*(1-p));
     }
 
-    Signature mix_sig = "mix($color-1, $color-2, $weight: 50%)";
+    Signature mix_sig = "mix($color1, $color2, $weight: 50%)";
     BUILT_IN(mix)
     {
-      Color_Obj  color1 = ARG("$color-1", Color);
-      Color_Obj  color2 = ARG("$color-2", Color);
+      Color_Obj  color1 = ARG("$color1", Color);
+      Color_Obj  color2 = ARG("$color2", Color);
       double weight = DARG_U_PRCT("$weight");
       return colormix(ctx, pstate, color1, color2, weight);
 
@@ -230,7 +230,7 @@ namespace Sass {
         Number_Obj val = SASS_MEMORY_COPY(alpha);
         val->numerators.clear(); // convert
         val->value(val->value() / 100.0);
-        std::string nr(val->to_string(ctx.c_options));
+        sass::string nr(val->to_string(ctx.c_options));
         hsla_alpha_percent_deprecation(pstate, nr);
       }
 
@@ -361,12 +361,16 @@ namespace Sass {
     {
       // CSS3 filter function overload: pass literal through directly
       Number* amount = Cast<Number>(env["$color"]);
+      double weight = DARG_U_PRCT("$weight");
       if (amount) {
+        // TODO: does not throw on 100% manually passed as value
+        if (weight < 100.0) {
+          error("Only one argument may be passed to the plain-CSS invert() function.", pstate, traces);
+        }
         return SASS_MEMORY_NEW(String_Quoted, pstate, "invert(" + amount->to_string(ctx.c_options) + ")");
       }
 
       Color* col = ARG("$color", Color);
-      double weight = DARG_U_PRCT("$weight");
       Color_RGBA_Obj inv = col->copyAsRGBA();
       inv->r(clip(255.0 - inv->r(), 0.0, 255.0));
       inv->g(clip(255.0 - inv->g(), 0.0, 255.0));
@@ -504,7 +508,7 @@ namespace Sass {
         double lscale = (l ? DARG_R_PRCT("$lightness") : 0.0) / 100.0;
         double ascale = (a ? DARG_R_PRCT("$alpha") : 0.0) / 100.0;
         if (hscale) c->h(c->h() + hscale * (hscale > 0.0 ? 360.0 - c->h() : c->h()));
-        if (sscale) c->s(c->s() + sscale * (sscale > 0.0 ? 100.0 - c->l() : c->s()));
+        if (sscale) c->s(c->s() + sscale * (sscale > 0.0 ? 100.0 - c->s() : c->s()));
         if (lscale) c->l(c->l() + lscale * (lscale > 0.0 ? 100.0 - c->l() : c->l()));
         if (ascale) c->a(c->a() + ascale * (ascale > 0.0 ? 1.0 - c->a() : c->a()));
         return c.detach();
@@ -575,17 +579,15 @@ namespace Sass {
       double b = clip(c->b(), 0.0, 255.0);
       double a = clip(c->a(), 0.0, 1.0) * 255.0;
 
-      std::stringstream ss;
+      sass::ostream ss;
       ss << '#' << std::setw(2) << std::setfill('0');
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(a, ctx.c_options.precision));
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(r, ctx.c_options.precision));
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(g, ctx.c_options.precision));
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(b, ctx.c_options.precision));
 
-      std::string result(ss.str());
-      for (size_t i = 0, L = result.length(); i < L; ++i) {
-        result[i] = std::toupper(result[i]);
-      }
+      sass::string result = ss.str();
+      Util::ascii_str_toupper(&result);
       return SASS_MEMORY_NEW(String_Quoted, pstate, result);
     }
 

data/ext/libsass/src/fn_lists.cpp

@@ -1,3 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
 #include "listize.hpp"
 #include "operators.hpp"
 #include "fn_utils.hpp"
@@ -17,9 +21,9 @@ namespace Sass {
       List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List)); // copy
       Map_Obj result = SASS_MEMORY_NEW(Map, pstate, 1);
       for (size_t i = arglist->size(), L = arglist->length(); i < L; ++i) {
-        Expression_Obj obj = arglist->at(i);
+        ExpressionObj obj = arglist->at(i);
         Argument_Obj arg = (Argument*) obj.ptr(); // XXX
-        std::string name = std::string(arg->name());
+        sass::string name = sass::string(arg->name());
         name = name.erase(0, 1); // sanitize name (remove dollar sign)
         *result << std::make_pair(SASS_MEMORY_NEW(String_Quoted,
                  pstate, name),
@@ -31,8 +35,8 @@ namespace Sass {
     Signature length_sig = "length($list)";
     BUILT_IN(length)
     {
-      if (Selector_List* sl = Cast<Selector_List>(env["$list"])) {
-        return SASS_MEMORY_NEW(Number, pstate, (double)sl->length());
+      if (SelectorList * sl = Cast<SelectorList>(env["$list"])) {
+        return SASS_MEMORY_NEW(Number, pstate, (double) sl->length());
       }
       Expression* v = ARG("$list", Expression);
       if (v->concrete_type() == Expression::MAP) {
@@ -40,9 +44,9 @@ namespace Sass {
         return SASS_MEMORY_NEW(Number, pstate, (double)(map ? map->length() : 1));
       }
       if (v->concrete_type() == Expression::SELECTOR) {
-        if (Compound_Selector* h = Cast<Compound_Selector>(v)) {
+        if (CompoundSelector * h = Cast<CompoundSelector>(v)) {
           return SASS_MEMORY_NEW(Number, pstate, (double)h->length());
-        } else if (Selector_List* ls = Cast<Selector_List>(v)) {
+        } else if (SelectorList * ls = Cast<SelectorList>(v)) {
           return SASS_MEMORY_NEW(Number, pstate, (double)ls->length());
         } else {
           return SASS_MEMORY_NEW(Number, pstate, 1);
@@ -60,18 +64,16 @@ namespace Sass {
     {
       double nr = ARGVAL("$n");
       Map* m = Cast<Map>(env["$list"]);
-      if (Selector_List* sl = Cast<Selector_List>(env["$list"])) {
+      if (SelectorList * sl = Cast<SelectorList>(env["$list"])) {
         size_t len = m ? m->length() : sl->length();
         bool empty = m ? m->empty() : sl->empty();
-        if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate, traces);
+        if (empty) error("argument `$list` of `" + sass::string(sig) + "` must not be empty", pstate, traces);
         double index = std::floor(nr < 0 ? len + nr : nr - 1);
-        if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate, traces);
-        // return (*sl)[static_cast<int>(index)];
-        Listize listize;
-        return Cast<Value>((*sl)[static_cast<int>(index)]->perform(&listize));
+        if (index < 0 || index > len - 1) error("index out of bounds for `" + sass::string(sig) + "`", pstate, traces);
+        return Cast<Value>(Listize::perform(sl->get(static_cast<int>(index))));
       }
       List_Obj l = Cast<List>(env["$list"]);
-      if (nr == 0) error("argument `$n` of `" + std::string(sig) + "` must be non-zero", pstate, traces);
+      if (nr == 0) error("argument `$n` of `" + sass::string(sig) + "` must be non-zero", pstate, traces);
       // if the argument isn't a list, then wrap it in a singleton list
       if (!m && !l) {
         l = SASS_MEMORY_NEW(List, pstate, 1);
@@ -79,9 +81,9 @@ namespace Sass {
       }
       size_t len = m ? m->length() : l->length();
       bool empty = m ? m->empty() : l->empty();
-      if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate, traces);
+      if (empty) error("argument `$list` of `" + sass::string(sig) + "` must not be empty", pstate, traces);
       double index = std::floor(nr < 0 ? len + nr : nr - 1);
-      if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate, traces);
+      if (index < 0 || index > len - 1) error("index out of bounds for `" + sass::string(sig) + "`", pstate, traces);
 
       if (m) {
         l = SASS_MEMORY_NEW(List, pstate, 2);
@@ -90,7 +92,7 @@ namespace Sass {
         return l.detach();
       }
       else {
-        Value_Obj rv = l->value_at_index(static_cast<int>(index));
+        ValueObj rv = l->value_at_index(static_cast<int>(index));
         rv->set_delayed(false);
         return rv.detach();
       }
@@ -102,7 +104,7 @@ namespace Sass {
       Map_Obj m = Cast<Map>(env["$list"]);
       List_Obj l = Cast<List>(env["$list"]);
       Number_Obj n = ARG("$n", Number);
-      Expression_Obj v = ARG("$value", Expression);
+      ExpressionObj v = ARG("$value", Expression);
       if (!l) {
         l = SASS_MEMORY_NEW(List, pstate, 1);
         l->append(ARG("$list", Expression));
@@ -110,9 +112,9 @@ namespace Sass {
       if (m) {
         l = m->to_list(pstate);
       }
-      if (l->empty()) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate, traces);
+      if (l->empty()) error("argument `$list` of `" + sass::string(sig) + "` must not be empty", pstate, traces);
       double index = std::floor(n->value() < 0 ? l->length() + n->value() : n->value() - 1);
-      if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate, traces);
+      if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + sass::string(sig) + "`", pstate, traces);
       List* result = SASS_MEMORY_NEW(List, pstate, l->length(), l->separator(), false, l->is_bracketed());
       for (size_t i = 0, L = l->length(); i < L; ++i) {
         result->append(((i == index) ? v : (*l)[i]));
@@ -125,7 +127,7 @@ namespace Sass {
     {
       Map_Obj m = Cast<Map>(env["$list"]);
       List_Obj l = Cast<List>(env["$list"]);
-      Expression_Obj v = ARG("$value", Expression);
+      ExpressionObj v = ARG("$value", Expression);
       if (!l) {
         l = SASS_MEMORY_NEW(List, pstate, 1);
         l->append(ARG("$list", Expression));
@@ -168,10 +170,10 @@ namespace Sass {
         l2 = m2->to_list(pstate);
       }
       size_t len = l1->length() + l2->length();
-      std::string sep_str = unquote(sep->value());
+      sass::string sep_str = unquote(sep->value());
       if (sep_str == "space") sep_val = SASS_SPACE;
       else if (sep_str == "comma") sep_val = SASS_COMMA;
-      else if (sep_str != "auto") error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate, traces);
+      else if (sep_str != "auto") error("argument `$separator` of `" + sass::string(sig) + "` must be `space`, `comma`, or `auto`", pstate, traces);
       String_Constant_Obj bracketed_as_str = Cast<String_Constant>(bracketed);
       bool bracketed_is_auto = bracketed_as_str && unquote(bracketed_as_str->value()) == "auto";
       if (!bracketed_is_auto) {
@@ -188,10 +190,9 @@ namespace Sass {
     {
       Map_Obj m = Cast<Map>(env["$list"]);
       List_Obj l = Cast<List>(env["$list"]);
-      Expression_Obj v = ARG("$val", Expression);
-      if (Selector_List* sl = Cast<Selector_List>(env["$list"])) {
-        Listize listize;
-        l = Cast<List>(sl->perform(&listize));
+      ExpressionObj v = ARG("$val", Expression);
+      if (SelectorList * sl = Cast<SelectorList>(env["$list"])) {
+        l = Cast<List>(Listize::perform(sl));
       }
       String_Constant_Obj sep = ARG("$separator", String_Constant);
       if (!l) {
@@ -202,11 +203,11 @@ namespace Sass {
         l = m->to_list(pstate);
       }
       List* result = SASS_MEMORY_COPY(l);
-      std::string sep_str(unquote(sep->value()));
+      sass::string sep_str(unquote(sep->value()));
       if (sep_str != "auto") { // check default first
         if (sep_str == "space") result->separator(SASS_SPACE);
         else if (sep_str == "comma") result->separator(SASS_COMMA);
-        else error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate, traces);
+        else error("argument `$separator` of `" + sass::string(sig) + "` must be `space`, `comma`, or `auto`", pstate, traces);
       }
       if (l->is_arglist()) {
         result->append(SASS_MEMORY_NEW(Argument,
@@ -274,7 +275,7 @@ namespace Sass {
     Signature is_bracketed_sig = "is-bracketed($list)";
     BUILT_IN(is_bracketed)
     {
-      Value_Obj value = ARG("$list", Value);
+      ValueObj value = ARG("$list", Value);
       List_Obj list = Cast<List>(value);
       return SASS_MEMORY_NEW(Boolean, pstate, list && list->is_bracketed());
     }

data/ext/libsass/src/fn_maps.cpp

@@ -16,9 +16,9 @@ namespace Sass {
       // leaks for "map-get((), foo)" if not Obj
       // investigate why this is (unexpected)
       Map_Obj m = ARGM("$map", Map);
-      Expression_Obj v = ARG("$key", Expression);
+      ExpressionObj v = ARG("$key", Expression);
       try {
-        Value_Obj val = m->at(v);
+        ValueObj val = m->at(v);
         if (!val) return SASS_MEMORY_NEW(Null, pstate);
         val->set_delayed(false);
         return val.detach();
@@ -32,7 +32,7 @@ namespace Sass {
     BUILT_IN(map_has_key)
     {
       Map_Obj m = ARGM("$map", Map);
-      Expression_Obj v = ARG("$key", Expression);
+      ExpressionObj v = ARG("$key", Expression);
       return SASS_MEMORY_NEW(Boolean, pstate, m->has(v));
     }
 

data/ext/libsass/src/fn_miscs.cpp

@@ -8,15 +8,6 @@ namespace Sass {
 
   namespace Functions {
 
-    // features
-    static std::set<std::string> features {
-      "global-variable-shadowing",
-      "extend-selector-pseudoclass",
-      "at-error",
-      "units-level-3",
-      "custom-property"
-    };
-
     //////////////////////////
     // INTROSPECTION FUNCTIONS
     //////////////////////////
@@ -31,7 +22,7 @@ namespace Sass {
     Signature variable_exists_sig = "variable-exists($name)";
     BUILT_IN(variable_exists)
     {
-      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      sass::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has("$"+s)) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
@@ -44,7 +35,7 @@ namespace Sass {
     Signature global_variable_exists_sig = "global-variable-exists($name)";
     BUILT_IN(global_variable_exists)
     {
-      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      sass::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has_global("$"+s)) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
@@ -62,7 +53,7 @@ namespace Sass {
         error("$name: " + (env["$name"]->to_string()) + " is not a string for `function-exists'", pstate, traces);
       }
 
-      std::string name = Util::normalize_underscores(unquote(ss->value()));
+      sass::string name = Util::normalize_underscores(unquote(ss->value()));
 
       if(d_env.has(name+"[f]")) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
@@ -75,7 +66,7 @@ namespace Sass {
     Signature mixin_exists_sig = "mixin-exists($name)";
     BUILT_IN(mixin_exists)
     {
-      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      sass::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has(s+"[m]")) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
@@ -85,52 +76,54 @@ namespace Sass {
       }
     }
 
-    Signature feature_exists_sig = "feature-exists($name)";
+    Signature feature_exists_sig = "feature-exists($feature)";
     BUILT_IN(feature_exists)
     {
-      std::string s = unquote(ARG("$name", String_Constant)->value());
-
-      if(features.find(s) == features.end()) {
-        return SASS_MEMORY_NEW(Boolean, pstate, false);
-      }
-      else {
-        return SASS_MEMORY_NEW(Boolean, pstate, true);
-      }
+      sass::string s = unquote(ARG("$feature", String_Constant)->value());
+
+      static const auto *const features = new std::unordered_set<sass::string> {
+        "global-variable-shadowing",
+        "extend-selector-pseudoclass",
+        "at-error",
+        "units-level-3",
+        "custom-property"
+      };
+      return SASS_MEMORY_NEW(Boolean, pstate, features->find(s) != features->end());
     }
 
-    Signature call_sig = "call($name, $args...)";
+    Signature call_sig = "call($function, $args...)";
     BUILT_IN(call)
     {
-      std::string name;
-      Function* ff = Cast<Function>(env["$name"]);
-      String_Constant* ss = Cast<String_Constant>(env["$name"]);
+      sass::string function;
+      Function* ff = Cast<Function>(env["$function"]);
+      String_Constant* ss = Cast<String_Constant>(env["$function"]);
 
       if (ss) {
-        name = Util::normalize_underscores(unquote(ss->value()));
+        function = Util::normalize_underscores(unquote(ss->value()));
         std::cerr << "DEPRECATION WARNING: ";
         std::cerr << "Passing a string to call() is deprecated and will be illegal" << std::endl;
-        std::cerr << "in Sass 4.0. Use call(get-function(" + quote(name) + ")) instead." << std::endl;
+        std::cerr << "in Sass 4.0. Use call(get-function(" + quote(function) + ")) instead." << std::endl;
         std::cerr << std::endl;
       } else if (ff) {
-        name = ff->name();
+        function = ff->name();
       }
 
       List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List));
 
       Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);
-      // std::string full_name(name + "[f]");
+      // sass::string full_name(name + "[f]");
       // Definition* def = d_env.has(full_name) ? Cast<Definition>((d_env)[full_name]) : 0;
       // Parameters* params = def ? def->parameters() : 0;
       // size_t param_size = params ? params->length() : 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Expression_Obj expr = arglist->value_at_index(i);
+        ExpressionObj expr = arglist->value_at_index(i);
         // if (params && params->has_rest_parameter()) {
         //   Parameter_Obj p = param_size > i ? (*params)[i] : 0;
         //   List* list = Cast<List>(expr);
         //   if (list && p && !p->is_rest_parameter()) expr = (*list)[0];
         // }
         if (arglist->is_arglist()) {
-          Expression_Obj obj = arglist->at(i);
+          ExpressionObj obj = arglist->at(i);
           Argument_Obj arg = (Argument*) obj.ptr(); // XXX
           args->append(SASS_MEMORY_NEW(Argument,
                                        pstate,
@@ -142,8 +135,9 @@ namespace Sass {
           args->append(SASS_MEMORY_NEW(Argument, pstate, expr));
         }
       }
-      Function_Call_Obj func = SASS_MEMORY_NEW(Function_Call, pstate, name, args);
-      Expand expand(ctx, &d_env, &selector_stack);
+      Function_Call_Obj func = SASS_MEMORY_NEW(Function_Call, pstate, function, args);
+
+      Expand expand(ctx, &d_env, &selector_stack, &original_stack);
       func->via_call(true); // calc invoke is allowed
       if (ff) func->func(ff);
       return Cast<PreValue>(func->perform(&expand.eval));
@@ -160,15 +154,13 @@ namespace Sass {
     }
 
     Signature if_sig = "if($condition, $if-true, $if-false)";
-    // BUILT_IN(sass_if)
-    // { return ARG("$condition", Expression)->is_false() ? ARG("$if-false", Expression) : ARG("$if-true", Expression); }
     BUILT_IN(sass_if)
     {
-      Expand expand(ctx, &d_env, &selector_stack);
-      Expression_Obj cond = ARG("$condition", Expression)->perform(&expand.eval);
+      Expand expand(ctx, &d_env, &selector_stack, &original_stack);
+      ExpressionObj cond = ARG("$condition", Expression)->perform(&expand.eval);
       bool is_true = !cond->is_false();
-      Expression_Obj res = ARG(is_true ? "$if-true" : "$if-false", Expression);
-      Value_Obj qwe = Cast<Value>(res->perform(&expand.eval));
+      ExpressionObj res = ARG(is_true ? "$if-true" : "$if-false", Expression);
+      ValueObj qwe = Cast<Value>(res->perform(&expand.eval));
       // res = res->perform(&expand.eval.val_eval);
       qwe->set_delayed(false); // clone?
       return qwe.detach();
@@ -178,9 +170,6 @@ namespace Sass {
     // MISCELLANEOUS FUNCTIONS
     //////////////////////////
 
-    // value.check_deprecated_interp if value.is_a?(Sass::Script::Value::String)
-    // unquoted_string(value.to_sass)
-
     Signature inspect_sig = "inspect($value)";
     BUILT_IN(inspect)
     {
@@ -208,7 +197,6 @@ namespace Sass {
         ctx.c_options.output_style = old_style;
         return SASS_MEMORY_NEW(String_Quoted, pstate, i.get_buffer());
       }
-      // return v;
     }
 
     Signature content_exists_sig = "content-exists()";
@@ -228,8 +216,8 @@ namespace Sass {
         error("$name: " + (env["$name"]->to_string()) + " is not a string for `get-function'", pstate, traces);
       }
 
-      std::string name = Util::normalize_underscores(unquote(ss->value()));
-      std::string full_name = name + "[f]";
+      sass::string name = Util::normalize_underscores(unquote(ss->value()));
+      sass::string full_name = name + "[f]";
 
       Boolean_Obj css = ARG("$css", Boolean);
       if (!css->is_false()) {