sassc 2.3.0 → 2.4.0

data/ext/libsass/src/ast_values.cpp

@@ -5,7 +5,7 @@
 
 namespace Sass {
 
-  void str_rtrim(std::string& str, const std::string& delimiters = " \f\n\r\t\v")
+  void str_rtrim(sass::string& str, const sass::string& delimiters = " \f\n\r\t\v")
   {
     str.erase( str.find_last_not_of( delimiters ) + 1 );
   }
@@ -13,7 +13,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  PreValue::PreValue(ParserState pstate, bool d, bool e, bool i, Type ct)
+  PreValue::PreValue(SourceSpan pstate, bool d, bool e, bool i, Type ct)
   : Expression(pstate, d, e, i, ct)
   { }
   PreValue::PreValue(const PreValue* ptr)
@@ -23,7 +23,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Value::Value(ParserState pstate, bool d, bool e, bool i, Type ct)
+  Value::Value(SourceSpan pstate, bool d, bool e, bool i, Type ct)
   : PreValue(pstate, d, e, i, ct)
   { }
   Value::Value(const Value* ptr)
@@ -33,9 +33,9 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  List::List(ParserState pstate, size_t size, enum Sass_Separator sep, bool argl, bool bracket)
+  List::List(SourceSpan pstate, size_t size, enum Sass_Separator sep, bool argl, bool bracket)
   : Value(pstate),
-    Vectorized<Expression_Obj>(size),
+    Vectorized<ExpressionObj>(size),
     separator_(sep),
     is_arglist_(argl),
     is_bracketed_(bracket),
@@ -44,7 +44,7 @@ namespace Sass {
 
   List::List(const List* ptr)
   : Value(ptr),
-    Vectorized<Expression_Obj>(*ptr),
+    Vectorized<ExpressionObj>(*ptr),
     separator_(ptr->separator_),
     is_arglist_(ptr->is_arglist_),
     is_bracketed_(ptr->is_bracketed_),
@@ -54,7 +54,7 @@ namespace Sass {
   size_t List::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()(sep_string());
+      hash_ = std::hash<sass::string>()(sep_string());
       hash_combine(hash_, std::hash<bool>()(is_bracketed()));
       for (size_t i = 0, L = length(); i < L; ++i)
         hash_combine(hash_, (elements()[i])->hash());
@@ -109,7 +109,7 @@ namespace Sass {
     // arglist expects a list of arguments
     // so we need to break before keywords
     for (size_t i = 0, L = length(); i < L; ++i) {
-      Expression_Obj obj = this->at(i);
+      ExpressionObj obj = this->at(i);
       if (Argument* arg = Cast<Argument>(obj)) {
         if (!arg->name().empty()) return i;
       }
@@ -118,8 +118,8 @@ namespace Sass {
   }
 
 
-  Expression_Obj List::value_at_index(size_t i) {
-    Expression_Obj obj = this->at(i);
+  ExpressionObj List::value_at_index(size_t i) {
+    ExpressionObj obj = this->at(i);
     if (is_arglist_) {
       if (Argument* arg = Cast<Argument>(obj)) {
         return arg->value();
@@ -134,7 +134,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Map::Map(ParserState pstate, size_t size)
+  Map::Map(SourceSpan pstate, size_t size)
   : Value(pstate),
     Hashed(size)
   { concrete_type(MAP); }
@@ -185,7 +185,7 @@ namespace Sass {
     return false;
   }
 
-  List_Obj Map::to_list(ParserState& pstate) {
+  List_Obj Map::to_list(SourceSpan& pstate) {
     List_Obj ret = SASS_MEMORY_NEW(List, pstate, length(), SASS_COMMA);
 
     for (auto key : keys()) {
@@ -213,8 +213,8 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Binary_Expression::Binary_Expression(ParserState pstate,
-                    Operand op, Expression_Obj lhs, Expression_Obj rhs)
+  Binary_Expression::Binary_Expression(SourceSpan pstate,
+                    Operand op, ExpressionObj lhs, ExpressionObj rhs)
   : PreValue(pstate), op_(op), left_(lhs), right_(rhs), hash_(0)
   { }
 
@@ -235,12 +235,12 @@ namespace Sass {
     return is_interpolant() || (right() && right()->is_right_interpolant());
   }
 
-  const std::string Binary_Expression::type_name()
+  const sass::string Binary_Expression::type_name()
   {
     return sass_op_to_name(optype());
   }
 
-  const std::string Binary_Expression::separator()
+  const sass::string Binary_Expression::separator()
   {
     return sass_op_separator(optype());
   }
@@ -292,7 +292,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Function::Function(ParserState pstate, Definition_Obj def, bool css)
+  Function::Function(SourceSpan pstate, Definition_Obj def, bool css)
   : Value(pstate), definition_(def), is_css_(css)
   { concrete_type(FUNCTION_VAL); }
 
@@ -326,7 +326,7 @@ namespace Sass {
     return false;
   }
 
-  std::string Function::name() {
+  sass::string Function::name() {
     if (definition_) {
       return definition_->name();
     }
@@ -336,23 +336,23 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Function_Call::Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args, void* cookie)
+  Function_Call::Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args, void* cookie)
   : PreValue(pstate), sname_(n), arguments_(args), func_(), via_call_(false), cookie_(cookie), hash_(0)
   { concrete_type(FUNCTION); }
-  Function_Call::Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args, Function_Obj func)
+  Function_Call::Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args, Function_Obj func)
   : PreValue(pstate), sname_(n), arguments_(args), func_(func), via_call_(false), cookie_(0), hash_(0)
   { concrete_type(FUNCTION); }
-  Function_Call::Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args)
+  Function_Call::Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args)
   : PreValue(pstate), sname_(n), arguments_(args), via_call_(false), cookie_(0), hash_(0)
   { concrete_type(FUNCTION); }
 
-  Function_Call::Function_Call(ParserState pstate, std::string n, Arguments_Obj args, void* cookie)
+  Function_Call::Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, void* cookie)
   : PreValue(pstate), sname_(SASS_MEMORY_NEW(String_Constant, pstate, n)), arguments_(args), func_(), via_call_(false), cookie_(cookie), hash_(0)
   { concrete_type(FUNCTION); }
-  Function_Call::Function_Call(ParserState pstate, std::string n, Arguments_Obj args, Function_Obj func)
+  Function_Call::Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, Function_Obj func)
   : PreValue(pstate), sname_(SASS_MEMORY_NEW(String_Constant, pstate, n)), arguments_(args), func_(func), via_call_(false), cookie_(0), hash_(0)
   { concrete_type(FUNCTION); }
-  Function_Call::Function_Call(ParserState pstate, std::string n, Arguments_Obj args)
+  Function_Call::Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args)
   : PreValue(pstate), sname_(SASS_MEMORY_NEW(String_Constant, pstate, n)), arguments_(args), via_call_(false), cookie_(0), hash_(0)
   { concrete_type(FUNCTION); }
 
@@ -381,14 +381,14 @@ namespace Sass {
   size_t Function_Call::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()(name());
+      hash_ = std::hash<sass::string>()(name());
       for (auto argument : arguments()->elements())
         hash_combine(hash_, argument->hash());
     }
     return hash_;
   }
 
-  std::string Function_Call::name() const
+  sass::string Function_Call::name() const
   {
     return sname();
   }
@@ -401,7 +401,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Variable::Variable(ParserState pstate, std::string n)
+  Variable::Variable(SourceSpan pstate, sass::string n)
   : PreValue(pstate), name_(n)
   { concrete_type(VARIABLE); }
 
@@ -419,13 +419,13 @@ namespace Sass {
 
   size_t Variable::hash() const
   {
-    return std::hash<std::string>()(name());
+    return std::hash<sass::string>()(name());
   }
 
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Number::Number(ParserState pstate, double val, std::string u, bool zero)
+  Number::Number(SourceSpan pstate, double val, sass::string u, bool zero)
   : Value(pstate),
     Units(),
     value_(val),
@@ -438,12 +438,12 @@ namespace Sass {
       bool nominator = true;
       while (true) {
         r = u.find_first_of("*/", l);
-        std::string unit(u.substr(l, r == std::string::npos ? r : r - l));
+        sass::string unit(u.substr(l, r == sass::string::npos ? r : r - l));
         if (!unit.empty()) {
           if (nominator) numerators.push_back(unit);
           else denominators.push_back(unit);
         }
-        if (r == std::string::npos) break;
+        if (r == sass::string::npos) break;
         // ToDo: should error for multiple slashes
         // if (!nominator && u[r] == '/') error(...)
         if (u[r] == '/')
@@ -482,9 +482,9 @@ namespace Sass {
     if (hash_ == 0) {
       hash_ = std::hash<double>()(value_);
       for (const auto numerator : numerators)
-        hash_combine(hash_, std::hash<std::string>()(numerator));
+        hash_combine(hash_, std::hash<sass::string>()(numerator));
       for (const auto denominator : denominators)
-        hash_combine(hash_, std::hash<std::string>()(denominator));
+        hash_combine(hash_, std::hash<sass::string>()(denominator));
     }
     return hash_;
   }
@@ -549,7 +549,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Color::Color(ParserState pstate, double a, const std::string disp)
+  Color::Color(SourceSpan pstate, double a, const sass::string disp)
   : Value(pstate),
     disp_(disp), a_(a),
     hash_(0)
@@ -595,7 +595,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Color_RGBA::Color_RGBA(ParserState pstate, double r, double g, double b, double a, const std::string disp)
+  Color_RGBA::Color_RGBA(SourceSpan pstate, double r, double g, double b, double a, const sass::string disp)
   : Color(pstate, a, disp),
     r_(r), g_(g), b_(b)
   { concrete_type(COLOR); }
@@ -638,7 +638,7 @@ namespace Sass {
   size_t Color_RGBA::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()("RGBA");
+      hash_ = std::hash<sass::string>()("RGBA");
       hash_combine(hash_, std::hash<double>()(a_));
       hash_combine(hash_, std::hash<double>()(r_));
       hash_combine(hash_, std::hash<double>()(g_));
@@ -693,7 +693,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Color_HSLA::Color_HSLA(ParserState pstate, double h, double s, double l, double a, const std::string disp)
+  Color_HSLA::Color_HSLA(SourceSpan pstate, double h, double s, double l, double a, const sass::string disp)
   : Color(pstate, a, disp),
     h_(absmod(h, 360.0)),
     s_(clip(s, 0.0, 100.0)),
@@ -740,7 +740,7 @@ namespace Sass {
   size_t Color_HSLA::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()("HSLA");
+      hash_ = std::hash<sass::string>()("HSLA");
       hash_combine(hash_, std::hash<double>()(a_));
       hash_combine(hash_, std::hash<double>()(h_));
       hash_combine(hash_, std::hash<double>()(s_));
@@ -789,7 +789,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Custom_Error::Custom_Error(ParserState pstate, std::string msg)
+  Custom_Error::Custom_Error(SourceSpan pstate, sass::string msg)
   : Value(pstate), message_(msg)
   { concrete_type(C_ERROR); }
 
@@ -817,7 +817,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Custom_Warning::Custom_Warning(ParserState pstate, std::string msg)
+  Custom_Warning::Custom_Warning(SourceSpan pstate, sass::string msg)
   : Value(pstate), message_(msg)
   { concrete_type(C_WARNING); }
 
@@ -845,7 +845,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Boolean::Boolean(ParserState pstate, bool val)
+  Boolean::Boolean(SourceSpan pstate, bool val)
   : Value(pstate), value_(val),
     hash_(0)
   { concrete_type(BOOLEAN); }
@@ -883,7 +883,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  String::String(ParserState pstate, bool delayed)
+  String::String(SourceSpan pstate, bool delayed)
   : Value(pstate, delayed)
   { concrete_type(STRING); }
   String::String(const String* ptr)
@@ -893,13 +893,13 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  String_Schema::String_Schema(ParserState pstate, size_t size, bool css)
-  : String(pstate), Vectorized<PreValue_Obj>(size), css_(css), hash_(0)
+  String_Schema::String_Schema(SourceSpan pstate, size_t size, bool css)
+  : String(pstate), Vectorized<PreValueObj>(size), css_(css), hash_(0)
   { concrete_type(STRING); }
 
   String_Schema::String_Schema(const String_Schema* ptr)
   : String(ptr),
-    Vectorized<PreValue_Obj>(*ptr),
+    Vectorized<PreValueObj>(*ptr),
     css_(ptr->css_),
     hash_(ptr->hash_)
   { concrete_type(STRING); }
@@ -976,17 +976,17 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  String_Constant::String_Constant(ParserState pstate, std::string val, bool css)
+  String_Constant::String_Constant(SourceSpan pstate, sass::string val, bool css)
   : String(pstate), quote_mark_(0), value_(read_css_string(val, css)), hash_(0)
   { }
-  String_Constant::String_Constant(ParserState pstate, const char* beg, bool css)
-  : String(pstate), quote_mark_(0), value_(read_css_string(std::string(beg), css)), hash_(0)
+  String_Constant::String_Constant(SourceSpan pstate, const char* beg, bool css)
+  : String(pstate), quote_mark_(0), value_(read_css_string(sass::string(beg), css)), hash_(0)
   { }
-  String_Constant::String_Constant(ParserState pstate, const char* beg, const char* end, bool css)
-  : String(pstate), quote_mark_(0), value_(read_css_string(std::string(beg, end-beg), css)), hash_(0)
+  String_Constant::String_Constant(SourceSpan pstate, const char* beg, const char* end, bool css)
+  : String(pstate), quote_mark_(0), value_(read_css_string(sass::string(beg, end-beg), css)), hash_(0)
   { }
-  String_Constant::String_Constant(ParserState pstate, const Token& tok, bool css)
-  : String(pstate), quote_mark_(0), value_(read_css_string(std::string(tok.begin, tok.end), css)), hash_(0)
+  String_Constant::String_Constant(SourceSpan pstate, const Token& tok, bool css)
+  : String(pstate), quote_mark_(0), value_(read_css_string(sass::string(tok.begin, tok.end), css)), hash_(0)
   { }
 
   String_Constant::String_Constant(const String_Constant* ptr)
@@ -1023,7 +1023,7 @@ namespace Sass {
     return false;
   }
 
-  std::string String_Constant::inspect() const
+  sass::string String_Constant::inspect() const
   {
     return quote(value_, '*');
   }
@@ -1036,7 +1036,7 @@ namespace Sass {
   size_t String_Constant::hash() const
   {
     if (hash_ == 0) {
-      hash_ = std::hash<std::string>()(value_);
+      hash_ = std::hash<sass::string>()(value_);
     }
     return hash_;
   }
@@ -1044,7 +1044,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  String_Quoted::String_Quoted(ParserState pstate, std::string val, char q,
+  String_Quoted::String_Quoted(SourceSpan pstate, sass::string val, char q,
     bool keep_utf8_escapes, bool skip_unquoting,
     bool strict_unquoting, bool css)
   : String_Constant(pstate, val, css)
@@ -1082,7 +1082,7 @@ namespace Sass {
     return false;
   }
 
-  std::string String_Quoted::inspect() const
+  sass::string String_Quoted::inspect() const
   {
     return quote(value_, '*');
   }
@@ -1090,7 +1090,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Null::Null(ParserState pstate)
+  Null::Null(SourceSpan pstate)
   : Value(pstate)
   { concrete_type(NULL_VAL); }
 
@@ -1119,7 +1119,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////////////
 
-  Parent_Reference::Parent_Reference(ParserState pstate)
+  Parent_Reference::Parent_Reference(SourceSpan pstate)
   : Value(pstate)
   { concrete_type(PARENT); }
 

data/ext/libsass/src/ast_values.hpp

@@ -13,7 +13,7 @@ namespace Sass {
   //////////////////////////////////////////////////////////////////////
   class PreValue : public Expression {
   public:
-    PreValue(ParserState pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
+    PreValue(SourceSpan pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
     ATTACH_VIRTUAL_AST_OPERATIONS(PreValue);
     virtual ~PreValue() { }
   };
@@ -23,7 +23,7 @@ namespace Sass {
   //////////////////////////////////////////////////////////////////////
   class Value : public PreValue {
   public:
-    Value(ParserState pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
+    Value(SourceSpan pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
 
     // Some obects are not meant to be compared
     // ToDo: maybe fallback to pointer comparison?
@@ -47,23 +47,23 @@ namespace Sass {
   // Lists of values, both comma- and space-separated (distinguished by a
   // type-tag.) Also used to represent variable-length argument lists.
   ///////////////////////////////////////////////////////////////////////
-  class List : public Value, public Vectorized<Expression_Obj> {
-    void adjust_after_pushing(Expression_Obj e) override { is_expanded(false); }
+  class List : public Value, public Vectorized<ExpressionObj> {
+    void adjust_after_pushing(ExpressionObj e) override { is_expanded(false); }
   private:
     ADD_PROPERTY(enum Sass_Separator, separator)
     ADD_PROPERTY(bool, is_arglist)
     ADD_PROPERTY(bool, is_bracketed)
     ADD_PROPERTY(bool, from_selector)
   public:
-    List(ParserState pstate, size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false, bool bracket = false);
-    std::string type() const override { return is_arglist_ ? "arglist" : "list"; }
-    static std::string type_name() { return "list"; }
+    List(SourceSpan pstate, size_t size = 0, enum Sass_Separator sep = SASS_SPACE, bool argl = false, bool bracket = false);
+    sass::string type() const override { return is_arglist_ ? "arglist" : "list"; }
+    static sass::string type_name() { return "list"; }
     const char* sep_string(bool compressed = false) const {
       return separator() == SASS_SPACE ?
         " " : (compressed ? "," : ", ");
     }
     bool is_invisible() const override { return empty() && !is_bracketed(); }
-    Expression_Obj value_at_index(size_t i);
+    ExpressionObj value_at_index(size_t i);
 
     virtual size_t hash() const override;
     virtual size_t size() const;
@@ -79,14 +79,14 @@ namespace Sass {
   ///////////////////////////////////////////////////////////////////////
   // Key value paris.
   ///////////////////////////////////////////////////////////////////////
-  class Map : public Value, public Hashed<Expression_Obj, Expression_Obj, Map_Obj> {
-    void adjust_after_pushing(std::pair<Expression_Obj, Expression_Obj> p) override { is_expanded(false); }
+  class Map : public Value, public Hashed<ExpressionObj, ExpressionObj, Map_Obj> {
+    void adjust_after_pushing(std::pair<ExpressionObj, ExpressionObj> p) override { is_expanded(false); }
   public:
-    Map(ParserState pstate, size_t size = 0);
-    std::string type() const override { return "map"; }
-    static std::string type_name() { return "map"; }
+    Map(SourceSpan pstate, size_t size = 0);
+    sass::string type() const override { return "map"; }
+    static sass::string type_name() { return "map"; }
     bool is_invisible() const override { return empty(); }
-    List_Obj to_list(ParserState& pstate);
+    List_Obj to_list(SourceSpan& pstate);
 
     virtual size_t hash() const override;
 
@@ -106,15 +106,15 @@ namespace Sass {
   class Binary_Expression : public PreValue {
   private:
     HASH_PROPERTY(Operand, op)
-    HASH_PROPERTY(Expression_Obj, left)
-    HASH_PROPERTY(Expression_Obj, right)
+    HASH_PROPERTY(ExpressionObj, left)
+    HASH_PROPERTY(ExpressionObj, right)
     mutable size_t hash_;
   public:
-    Binary_Expression(ParserState pstate,
-                      Operand op, Expression_Obj lhs, Expression_Obj rhs);
+    Binary_Expression(SourceSpan pstate,
+                      Operand op, ExpressionObj lhs, ExpressionObj rhs);
 
-    const std::string type_name();
-    const std::string separator();
+    const sass::string type_name();
+    const sass::string separator();
     bool is_left_interpolant(void) const override;
     bool is_right_interpolant(void) const override;
     bool has_interpolant() const override;
@@ -138,13 +138,13 @@ namespace Sass {
     ADD_PROPERTY(Definition_Obj, definition)
     ADD_PROPERTY(bool, is_css)
   public:
-    Function(ParserState pstate, Definition_Obj def, bool css);
+    Function(SourceSpan pstate, Definition_Obj def, bool css);
 
-    std::string type() const override { return "function"; }
-    static std::string type_name() { return "function"; }
+    sass::string type() const override { return "function"; }
+    static sass::string type_name() { return "function"; }
     bool is_invisible() const override { return true; }
 
-    std::string name();
+    sass::string name();
 
     bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
@@ -164,15 +164,15 @@ namespace Sass {
     ADD_PROPERTY(void*, cookie)
     mutable size_t hash_;
   public:
-    Function_Call(ParserState pstate, std::string n, Arguments_Obj args, void* cookie);
-    Function_Call(ParserState pstate, std::string n, Arguments_Obj args, Function_Obj func);
-    Function_Call(ParserState pstate, std::string n, Arguments_Obj args);
+    Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, void* cookie);
+    Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, Function_Obj func);
+    Function_Call(SourceSpan pstate, sass::string n, Arguments_Obj args);
 
-    Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args, void* cookie);
-    Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args, Function_Obj func);
-    Function_Call(ParserState pstate, String_Obj n, Arguments_Obj args);
+    Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args, void* cookie);
+    Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args, Function_Obj func);
+    Function_Call(SourceSpan pstate, String_Obj n, Arguments_Obj args);
 
-    std::string name() const;
+    sass::string name() const;
     bool is_css();
 
     bool operator==(const Expression& rhs) const override;
@@ -187,9 +187,9 @@ namespace Sass {
   // Variable references.
   ///////////////////////
   class Variable final : public PreValue {
-    ADD_CONSTREF(std::string, name)
+    ADD_CONSTREF(sass::string, name)
   public:
-    Variable(ParserState pstate, std::string n);
+    Variable(SourceSpan pstate, sass::string n);
     virtual bool operator==(const Expression& rhs) const override;
     virtual size_t hash() const override;
     ATTACH_AST_OPERATIONS(Variable)
@@ -204,12 +204,12 @@ namespace Sass {
     ADD_PROPERTY(bool, zero)
     mutable size_t hash_;
   public:
-    Number(ParserState pstate, double val, std::string u = "", bool zero = true);
+    Number(SourceSpan pstate, double val, sass::string u = "", bool zero = true);
 
     bool zero() { return zero_; }
 
-    std::string type() const override { return "number"; }
-    static std::string type_name() { return "number"; }
+    sass::string type() const override { return "number"; }
+    static sass::string type_name() { return "number"; }
 
     // cancel out unnecessary units
     // result will be in input units
@@ -233,15 +233,15 @@ namespace Sass {
   // Colors.
   //////////
   class Color : public Value {
-    ADD_CONSTREF(std::string, disp)
+    ADD_CONSTREF(sass::string, disp)
     HASH_PROPERTY(double, a)
   protected:
     mutable size_t hash_;
   public:
-    Color(ParserState pstate, double a = 1, const std::string disp = "");
+    Color(SourceSpan pstate, double a = 1, const sass::string disp = "");
 
-    std::string type() const override { return "color"; }
-    static std::string type_name() { return "color"; }
+    sass::string type() const override { return "color"; }
+    static sass::string type_name() { return "color"; }
 
     virtual size_t hash() const override = 0;
 
@@ -265,10 +265,10 @@ namespace Sass {
     HASH_PROPERTY(double, g)
     HASH_PROPERTY(double, b)
   public:
-    Color_RGBA(ParserState pstate, double r, double g, double b, double a = 1, const std::string disp = "");
+    Color_RGBA(SourceSpan pstate, double r, double g, double b, double a = 1, const sass::string disp = "");
 
-    std::string type() const override { return "color"; }
-    static std::string type_name() { return "color"; }
+    sass::string type() const override { return "color"; }
+    static sass::string type_name() { return "color"; }
 
     size_t hash() const override;
 
@@ -294,10 +294,10 @@ namespace Sass {
     HASH_PROPERTY(double, s)
     HASH_PROPERTY(double, l)
   public:
-    Color_HSLA(ParserState pstate, double h, double s, double l, double a = 1, const std::string disp = "");
+    Color_HSLA(SourceSpan pstate, double h, double s, double l, double a = 1, const sass::string disp = "");
 
-    std::string type() const override { return "color"; }
-    static std::string type_name() { return "color"; }
+    sass::string type() const override { return "color"; }
+    static sass::string type_name() { return "color"; }
 
     size_t hash() const override;
 
@@ -318,9 +318,9 @@ namespace Sass {
   // Errors from Sass_Values.
   //////////////////////////////
   class Custom_Error final : public Value {
-    ADD_CONSTREF(std::string, message)
+    ADD_CONSTREF(sass::string, message)
   public:
-    Custom_Error(ParserState pstate, std::string msg);
+    Custom_Error(SourceSpan pstate, sass::string msg);
     bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
     ATTACH_AST_OPERATIONS(Custom_Error)
@@ -331,9 +331,9 @@ namespace Sass {
   // Warnings from Sass_Values.
   //////////////////////////////
   class Custom_Warning final : public Value {
-    ADD_CONSTREF(std::string, message)
+    ADD_CONSTREF(sass::string, message)
   public:
-    Custom_Warning(ParserState pstate, std::string msg);
+    Custom_Warning(SourceSpan pstate, sass::string msg);
     bool operator< (const Expression& rhs) const override;
     bool operator== (const Expression& rhs) const override;
     ATTACH_AST_OPERATIONS(Custom_Warning)
@@ -347,11 +347,11 @@ namespace Sass {
     HASH_PROPERTY(bool, value)
     mutable size_t hash_;
   public:
-    Boolean(ParserState pstate, bool val);
+    Boolean(SourceSpan pstate, bool val);
     operator bool() override { return value_; }
 
-    std::string type() const override { return "bool"; }
-    static std::string type_name() { return "bool"; }
+    sass::string type() const override { return "bool"; }
+    static sass::string type_name() { return "bool"; }
 
     size_t hash() const override;
 
@@ -370,8 +370,8 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////
   class String : public Value {
   public:
-    String(ParserState pstate, bool delayed = false);
-    static std::string type_name() { return "string"; }
+    String(SourceSpan pstate, bool delayed = false);
+    static sass::string type_name() { return "string"; }
     virtual ~String() = 0;
     virtual void rtrim() = 0;
     virtual bool operator<(const Expression& rhs) const override {
@@ -389,14 +389,14 @@ namespace Sass {
   // Interpolated strings. Meant to be reduced to flat strings during the
   // evaluation phase.
   ///////////////////////////////////////////////////////////////////////
-  class String_Schema final : public String, public Vectorized<PreValue_Obj> {
+  class String_Schema final : public String, public Vectorized<PreValueObj> {
     ADD_PROPERTY(bool, css)
     mutable size_t hash_;
   public:
-    String_Schema(ParserState pstate, size_t size = 0, bool css = true);
+    String_Schema(SourceSpan pstate, size_t size = 0, bool css = true);
 
-    std::string type() const override { return "string"; }
-    static std::string type_name() { return "string"; }
+    sass::string type() const override { return "string"; }
+    static sass::string type_name() { return "string"; }
 
     bool is_left_interpolant(void) const override;
     bool is_right_interpolant(void) const override;
@@ -417,23 +417,23 @@ namespace Sass {
   ////////////////////////////////////////////////////////
   class String_Constant : public String {
     ADD_PROPERTY(char, quote_mark)
-    HASH_CONSTREF(std::string, value)
+    HASH_CONSTREF(sass::string, value)
   protected:
     mutable size_t hash_;
   public:
-    String_Constant(ParserState pstate, std::string val, bool css = true);
-    String_Constant(ParserState pstate, const char* beg, bool css = true);
-    String_Constant(ParserState pstate, const char* beg, const char* end, bool css = true);
-    String_Constant(ParserState pstate, const Token& tok, bool css = true);
-    std::string type() const override { return "string"; }
-    static std::string type_name() { return "string"; }
+    String_Constant(SourceSpan pstate, sass::string val, bool css = true);
+    String_Constant(SourceSpan pstate, const char* beg, bool css = true);
+    String_Constant(SourceSpan pstate, const char* beg, const char* end, bool css = true);
+    String_Constant(SourceSpan pstate, const Token& tok, bool css = true);
+    sass::string type() const override { return "string"; }
+    static sass::string type_name() { return "string"; }
     bool is_invisible() const override;
     virtual void rtrim() override;
     size_t hash() const override;
     bool operator< (const Expression& rhs) const override;
     bool operator==(const Expression& rhs) const override;
     // quotes are forced on inspection
-    virtual std::string inspect() const override;
+    virtual sass::string inspect() const override;
     ATTACH_AST_OPERATIONS(String_Constant)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -443,13 +443,13 @@ namespace Sass {
   ////////////////////////////////////////////////////////
   class String_Quoted final : public String_Constant {
   public:
-    String_Quoted(ParserState pstate, std::string val, char q = 0,
+    String_Quoted(SourceSpan pstate, sass::string val, char q = 0,
       bool keep_utf8_escapes = false, bool skip_unquoting = false,
       bool strict_unquoting = true, bool css = true);
     bool operator< (const Expression& rhs) const override;
     bool operator==(const Expression& rhs) const override;
     // quotes are forced on inspection
-    std::string inspect() const override;
+    sass::string inspect() const override;
     ATTACH_AST_OPERATIONS(String_Quoted)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -459,9 +459,9 @@ namespace Sass {
   //////////////////
   class Null final : public Value {
   public:
-    Null(ParserState pstate);
-    std::string type() const override { return "null"; }
-    static std::string type_name() { return "null"; }
+    Null(SourceSpan pstate);
+    sass::string type() const override { return "null"; }
+    static sass::string type_name() { return "null"; }
     bool is_invisible() const override { return true; }
     operator bool() override { return false; }
     bool is_false() override { return true; }
@@ -480,9 +480,9 @@ namespace Sass {
   //////////////////////////////////
   class Parent_Reference final : public Value {
   public:
-    Parent_Reference(ParserState pstate);
-    std::string type() const override { return "parent"; }
-    static std::string type_name() { return "parent"; }
+    Parent_Reference(SourceSpan pstate);
+    sass::string type() const override { return "parent"; }
+    static sass::string type_name() { return "parent"; }
     bool operator< (const Expression& rhs) const override {
       return false; // they are always equal
     }