sassc 2.3.0 → 2.4.0

data/ext/libsass/src/ast.hpp

@@ -55,9 +55,9 @@ namespace Sass {
   // Abstract base class for all abstract syntax tree nodes.
   //////////////////////////////////////////////////////////
   class AST_Node : public SharedObj {
-    ADD_PROPERTY(ParserState, pstate)
+    ADD_PROPERTY(SourceSpan, pstate)
   public:
-    AST_Node(ParserState pstate)
+    AST_Node(SourceSpan pstate)
     : pstate_(pstate)
     { }
     AST_Node(const AST_Node* ptr)
@@ -66,7 +66,7 @@ namespace Sass {
 
     // allow implicit conversion to string
     // needed for by SharedPtr implementation
-    operator std::string() {
+    operator sass::string() {
       return to_string();
     }
 
@@ -74,27 +74,25 @@ namespace Sass {
 
     virtual ~AST_Node() = 0;
     virtual size_t hash() const { return 0; }
-    virtual std::string inspect() const { return to_string({ INSPECT, 5 }); }
-    virtual std::string to_sass() const { return to_string({ TO_SASS, 5 }); }
-    virtual std::string to_string(Sass_Inspect_Options opt) const;
-    virtual std::string to_css(Sass_Inspect_Options opt) const;
-    virtual std::string to_string() const;
+    virtual sass::string inspect() const { return to_string({ INSPECT, 5 }); }
+    virtual sass::string to_sass() const { return to_string({ TO_SASS, 5 }); }
+    virtual sass::string to_string(Sass_Inspect_Options opt) const;
+    virtual sass::string to_css(Sass_Inspect_Options opt) const;
+    virtual sass::string to_string() const;
     virtual void cloneChildren() {};
     // generic find function (not fully implemented yet)
-    // ToDo: add specific implementions to all children
+    // ToDo: add specific implementations to all children
     virtual bool find ( bool (*f)(AST_Node_Obj) ) { return f(this); };
-    void update_pstate(const ParserState& pstate);
-    Offset off() { return pstate(); }
-    Position pos() { return pstate(); }
+    void update_pstate(const SourceSpan& pstate);
 
-    // Some obects are not meant to be compared
-    // ToDo: maybe fallback to pointer comparison?
+    // Some objects are not meant to be compared
+    // ToDo: maybe fall-back to pointer comparison?
     virtual bool operator== (const AST_Node& rhs) const {
       throw std::runtime_error("operator== not implemented");
     }
 
     // We can give some reasonable implementations by using
-    // inverst operators on the specialized implementations
+    // invert operators on the specialized implementations
     virtual bool operator!= (const AST_Node& rhs) const {
       // Unequal if not equal
       return !(*this == rhs);
@@ -153,13 +151,13 @@ namespace Sass {
     ADD_PROPERTY(bool, is_interpolant)
     ADD_PROPERTY(Type, concrete_type)
   public:
-    Expression(ParserState pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
+    Expression(SourceSpan pstate, bool d = false, bool e = false, bool i = false, Type ct = NONE);
     virtual operator bool() { return true; }
     virtual ~Expression() { }
     virtual bool is_invisible() const { return false; }
 
-    virtual std::string type() const { return ""; }
-    static std::string type_name() { return ""; }
+    virtual sass::string type() const { return ""; }
+    static sass::string type_name() { return ""; }
 
     virtual bool is_false() { return false; }
     // virtual bool is_true() { return !is_false(); }
@@ -184,17 +182,17 @@ namespace Sass {
 
 namespace std {
   template<>
-  struct hash<Sass::Expression_Obj>
+  struct hash<Sass::ExpressionObj>
   {
-    size_t operator()(Sass::Expression_Obj s) const
+    size_t operator()(Sass::ExpressionObj s) const
     {
       return s->hash();
     }
   };
   template<>
-  struct equal_to<Sass::Expression_Obj>
+  struct equal_to<Sass::ExpressionObj>
   {
-    bool operator()( Sass::Expression_Obj lhs,  Sass::Expression_Obj rhs) const
+    bool operator()( Sass::ExpressionObj lhs,  Sass::ExpressionObj rhs) const
     {
       return lhs->hash() == rhs->hash();
     }
@@ -210,7 +208,7 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////////
   template <typename T>
   class Vectorized {
-    std::vector<T> elements_;
+    sass::vector<T> elements_;
   protected:
     mutable size_t hash_;
     void reset_hash() { hash_ = 0; }
@@ -218,7 +216,7 @@ namespace Sass {
   public:
     Vectorized(size_t s = 0) : hash_(0)
     { elements_.reserve(s); }
-    Vectorized(std::vector<T> vec) :
+    Vectorized(sass::vector<T> vec) :
       elements_(std::move(vec)),
       hash_(0)
     {}
@@ -248,23 +246,23 @@ namespace Sass {
     const T& get(size_t i) const { return elements_[i]; }
     const T& operator[](size_t i) const { return elements_[i]; }
 
-    // Implicitly get the std::vector from our object
-    // Makes the Vector directly assignable to std::vector
+    // Implicitly get the sass::vector from our object
+    // Makes the Vector directly assignable to sass::vector
     // You are responsible to make a copy if needed
     // Note: since this returns the real object, we can't
     // Note: guarantee that the hash will not get out of sync
-    operator std::vector<T>&() { return elements_; }
-    operator const std::vector<T>&() const { return elements_; }
+    operator sass::vector<T>&() { return elements_; }
+    operator const sass::vector<T>&() const { return elements_; }
 
-    // Explicitly request all elements as a real std::vector
+    // Explicitly request all elements as a real sass::vector
     // You are responsible to make a copy if needed
     // Note: since this returns the real object, we can't
     // Note: guarantee that the hash will not get out of sync
-    std::vector<T>& elements() { return elements_; }
-    const std::vector<T>& elements() const { return elements_; }
+    sass::vector<T>& elements() { return elements_; }
+    const sass::vector<T>& elements() const { return elements_; }
 
     // Insert all items from compatible vector
-    void concat(const std::vector<T>& v)
+    void concat(const sass::vector<T>& v)
     {
       if (!v.empty()) reset_hash();
       elements().insert(end(), v.begin(), v.end());
@@ -320,7 +318,7 @@ namespace Sass {
     }
 
     // This might be better implemented as `operator=`?
-    void elements(std::vector<T> e) {
+    void elements(sass::vector<T> e) {
       reset_hash();
       elements_ = std::move(e);
     }
@@ -336,17 +334,17 @@ namespace Sass {
     }
 
     template <typename P, typename V>
-    typename std::vector<T>::iterator insert(P position, const V& val) {
+    typename sass::vector<T>::iterator insert(P position, const V& val) {
       reset_hash();
       return elements_.insert(position, val);
     }
 
-    typename std::vector<T>::iterator end() { return elements_.end(); }
-    typename std::vector<T>::iterator begin() { return elements_.begin(); }
-    typename std::vector<T>::const_iterator end() const { return elements_.end(); }
-    typename std::vector<T>::const_iterator begin() const { return elements_.begin(); }
-    typename std::vector<T>::iterator erase(typename std::vector<T>::iterator el) { reset_hash(); return elements_.erase(el); }
-    typename std::vector<T>::const_iterator erase(typename std::vector<T>::const_iterator el) { reset_hash(); return elements_.erase(el); }
+    typename sass::vector<T>::iterator end() { return elements_.end(); }
+    typename sass::vector<T>::iterator begin() { return elements_.begin(); }
+    typename sass::vector<T>::const_iterator end() const { return elements_.end(); }
+    typename sass::vector<T>::const_iterator begin() const { return elements_.begin(); }
+    typename sass::vector<T>::iterator erase(typename sass::vector<T>::iterator el) { reset_hash(); return elements_.erase(el); }
+    typename sass::vector<T>::const_iterator erase(typename sass::vector<T>::const_iterator el) { reset_hash(); return elements_.erase(el); }
 
   };
   template <typename T>
@@ -354,7 +352,7 @@ namespace Sass {
 
   /////////////////////////////////////////////////////////////////////////////
   // Mixin class for AST nodes that should behave like a hash table. Uses an
-  // extra <std::vector> internally to maintain insertion order for interation.
+  // extra <sass::vector> internally to maintain insertion order for interation.
   /////////////////////////////////////////////////////////////////////////////
   template <typename K, typename T, typename U>
   class Hashed {
@@ -363,8 +361,8 @@ namespace Sass {
       K, T, ObjHash, ObjEquality
     > elements_;
 
-    std::vector<K> _keys;
-    std::vector<T> _values;
+    sass::vector<K> _keys;
+    sass::vector<T> _values;
   protected:
     mutable size_t hash_;
     K duplicate_key_;
@@ -437,13 +435,13 @@ namespace Sass {
       K, T, ObjHash, ObjEquality
     >& pairs() const { return elements_; }
 
-    const std::vector<K>& keys() const { return _keys; }
-    const std::vector<T>& values() const { return _values; }
+    const sass::vector<K>& keys() const { return _keys; }
+    const sass::vector<T>& values() const { return _values; }
 
-//    std::unordered_map<Expression_Obj, Expression_Obj>::iterator end() { return elements_.end(); }
-//    std::unordered_map<Expression_Obj, Expression_Obj>::iterator begin() { return elements_.begin(); }
-//    std::unordered_map<Expression_Obj, Expression_Obj>::const_iterator end() const { return elements_.end(); }
-//    std::unordered_map<Expression_Obj, Expression_Obj>::const_iterator begin() const { return elements_.begin(); }
+//    std::unordered_map<ExpressionObj, ExpressionObj>::iterator end() { return elements_.end(); }
+//    std::unordered_map<ExpressionObj, ExpressionObj>::iterator begin() { return elements_.begin(); }
+//    std::unordered_map<ExpressionObj, ExpressionObj>::const_iterator end() const { return elements_.end(); }
+//    std::unordered_map<ExpressionObj, ExpressionObj>::const_iterator begin() const { return elements_.begin(); }
 
   };
   template <typename K, typename T, typename U>
@@ -486,7 +484,7 @@ namespace Sass {
     ADD_PROPERTY(size_t, tabs)
     ADD_PROPERTY(bool, group_end)
   public:
-    Statement(ParserState pstate, Type st = NONE, size_t t = 0);
+    Statement(SourceSpan pstate, Type st = NONE, size_t t = 0);
     virtual ~Statement() = 0; // virtual destructor
     // needed for rearranging nested rulesets during CSS emission
     virtual bool bubbles();
@@ -505,7 +503,7 @@ namespace Sass {
   protected:
     void adjust_after_pushing(Statement_Obj s) override {}
   public:
-    Block(ParserState pstate, size_t s = 0, bool r = false);
+    Block(SourceSpan pstate, size_t s = 0, bool r = false);
     bool isInvisible() const;
     bool has_content() override;
     ATTACH_AST_OPERATIONS(Block)
@@ -515,28 +513,28 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////
   // Abstract base class for statements that contain blocks of statements.
   ////////////////////////////////////////////////////////////////////////
-  class Has_Block : public Statement {
+  class ParentStatement : public Statement {
     ADD_PROPERTY(Block_Obj, block)
   public:
-    Has_Block(ParserState pstate, Block_Obj b);
-    Has_Block(const Has_Block* ptr); // copy constructor
-    virtual ~Has_Block() = 0; // virtual destructor
+    ParentStatement(SourceSpan pstate, Block_Obj b);
+    ParentStatement(const ParentStatement* ptr); // copy constructor
+    virtual ~ParentStatement() = 0; // virtual destructor
     virtual bool has_content() override;
   };
-  inline Has_Block::~Has_Block() { }
+  inline ParentStatement::~ParentStatement() { }
 
   /////////////////////////////////////////////////////////////////////////////
   // Rulesets (i.e., sets of styles headed by a selector and containing a block
   // of style declarations.
   /////////////////////////////////////////////////////////////////////////////
-  class Ruleset final : public Has_Block {
+  class StyleRule final : public ParentStatement {
     ADD_PROPERTY(SelectorListObj, selector)
     ADD_PROPERTY(Selector_Schema_Obj, schema)
     ADD_PROPERTY(bool, is_root);
   public:
-    Ruleset(ParserState pstate, SelectorListObj s = {}, Block_Obj b = {});
+    StyleRule(SourceSpan pstate, SelectorListObj s = {}, Block_Obj b = {});
     bool is_invisible() const override;
-    ATTACH_AST_OPERATIONS(Ruleset)
+    ATTACH_AST_OPERATIONS(StyleRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
@@ -547,7 +545,7 @@ namespace Sass {
     ADD_PROPERTY(Statement_Obj, node)
     ADD_PROPERTY(bool, group_end)
   public:
-    Bubble(ParserState pstate, Statement_Obj n, Statement_Obj g = {}, size_t t = 0);
+    Bubble(SourceSpan pstate, Statement_Obj n, Statement_Obj g = {}, size_t t = 0);
     bool bubbles() override;
     ATTACH_AST_OPERATIONS(Bubble)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -556,11 +554,11 @@ namespace Sass {
   /////////////////
   // Trace.
   /////////////////
-  class Trace final : public Has_Block {
+  class Trace final : public ParentStatement {
     ADD_CONSTREF(char, type)
-    ADD_CONSTREF(std::string, name)
+    ADD_CONSTREF(sass::string, name)
   public:
-    Trace(ParserState pstate, std::string n, Block_Obj b = {}, char type = 'm');
+    Trace(SourceSpan pstate, sass::string n, Block_Obj b = {}, char type = 'm');
     ATTACH_AST_OPERATIONS(Trace)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -569,28 +567,28 @@ namespace Sass {
   // At-rules -- arbitrary directives beginning with "@" that may have an
   // optional statement block.
   ///////////////////////////////////////////////////////////////////////
-  class Directive final : public Has_Block {
-    ADD_CONSTREF(std::string, keyword)
+  class AtRule final : public ParentStatement {
+    ADD_CONSTREF(sass::string, keyword)
     ADD_PROPERTY(SelectorListObj, selector)
-    ADD_PROPERTY(Expression_Obj, value)
+    ADD_PROPERTY(ExpressionObj, value)
   public:
-    Directive(ParserState pstate, std::string kwd, SelectorListObj sel = {}, Block_Obj b = {}, Expression_Obj val = {});
+    AtRule(SourceSpan pstate, sass::string kwd, SelectorListObj sel = {}, Block_Obj b = {}, ExpressionObj val = {});
     bool bubbles() override;
     bool is_media();
     bool is_keyframes();
-    ATTACH_AST_OPERATIONS(Directive)
+    ATTACH_AST_OPERATIONS(AtRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ///////////////////////////////////////////////////////////////////////
   // Keyframe-rules -- the child blocks of "@keyframes" nodes.
   ///////////////////////////////////////////////////////////////////////
-  class Keyframe_Rule final : public Has_Block {
+  class Keyframe_Rule final : public ParentStatement {
     // according to css spec, this should be <keyframes-name>
     // <keyframes-name> = <custom-ident> | <string>
     ADD_PROPERTY(SelectorListObj, name)
   public:
-    Keyframe_Rule(ParserState pstate, Block_Obj b);
+    Keyframe_Rule(SourceSpan pstate, Block_Obj b);
     ATTACH_AST_OPERATIONS(Keyframe_Rule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -598,14 +596,14 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////
   // Declarations -- style rules consisting of a property name and values.
   ////////////////////////////////////////////////////////////////////////
-  class Declaration final : public Has_Block {
+  class Declaration final : public ParentStatement {
     ADD_PROPERTY(String_Obj, property)
-    ADD_PROPERTY(Expression_Obj, value)
+    ADD_PROPERTY(ExpressionObj, value)
     ADD_PROPERTY(bool, is_important)
     ADD_PROPERTY(bool, is_custom_property)
     ADD_PROPERTY(bool, is_indented)
   public:
-    Declaration(ParserState pstate, String_Obj prop, Expression_Obj val, bool i = false, bool c = false, Block_Obj b = {});
+    Declaration(SourceSpan pstate, String_Obj prop, ExpressionObj val, bool i = false, bool c = false, Block_Obj b = {});
     bool is_invisible() const override;
     ATTACH_AST_OPERATIONS(Declaration)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -615,12 +613,12 @@ namespace Sass {
   // Assignments -- variable and value.
   /////////////////////////////////////
   class Assignment final : public Statement {
-    ADD_CONSTREF(std::string, variable)
-    ADD_PROPERTY(Expression_Obj, value)
+    ADD_CONSTREF(sass::string, variable)
+    ADD_PROPERTY(ExpressionObj, value)
     ADD_PROPERTY(bool, is_default)
     ADD_PROPERTY(bool, is_global)
   public:
-    Assignment(ParserState pstate, std::string var, Expression_Obj val, bool is_default = false, bool is_global = false);
+    Assignment(SourceSpan pstate, sass::string var, ExpressionObj val, bool is_default = false, bool is_global = false);
     ATTACH_AST_OPERATIONS(Assignment)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -630,13 +628,13 @@ namespace Sass {
   // necessary to store a list of each in an Import node.
   ////////////////////////////////////////////////////////////////////////////
   class Import final : public Statement {
-    std::vector<Expression_Obj> urls_;
-    std::vector<Include>        incs_;
+    sass::vector<ExpressionObj> urls_;
+    sass::vector<Include>        incs_;
     ADD_PROPERTY(List_Obj,      import_queries);
   public:
-    Import(ParserState pstate);
-    std::vector<Include>& incs();
-    std::vector<Expression_Obj>& urls();
+    Import(SourceSpan pstate);
+    sass::vector<Include>& incs();
+    sass::vector<ExpressionObj>& urls();
     ATTACH_AST_OPERATIONS(Import)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -646,10 +644,10 @@ namespace Sass {
   class Import_Stub final : public Statement {
     Include resource_;
   public:
-    Import_Stub(ParserState pstate, Include res);
+    Import_Stub(SourceSpan pstate, Include res);
     Include resource();
-    std::string imp_path();
-    std::string abs_path();
+    sass::string imp_path();
+    sass::string abs_path();
     ATTACH_AST_OPERATIONS(Import_Stub)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -657,33 +655,33 @@ namespace Sass {
   //////////////////////////////
   // The Sass `@warn` directive.
   //////////////////////////////
-  class Warning final : public Statement {
-    ADD_PROPERTY(Expression_Obj, message)
+  class WarningRule final : public Statement {
+    ADD_PROPERTY(ExpressionObj, message)
   public:
-    Warning(ParserState pstate, Expression_Obj msg);
-    ATTACH_AST_OPERATIONS(Warning)
+    WarningRule(SourceSpan pstate, ExpressionObj msg);
+    ATTACH_AST_OPERATIONS(WarningRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ///////////////////////////////
   // The Sass `@error` directive.
   ///////////////////////////////
-  class Error final : public Statement {
-    ADD_PROPERTY(Expression_Obj, message)
+  class ErrorRule final : public Statement {
+    ADD_PROPERTY(ExpressionObj, message)
   public:
-    Error(ParserState pstate, Expression_Obj msg);
-    ATTACH_AST_OPERATIONS(Error)
+    ErrorRule(SourceSpan pstate, ExpressionObj msg);
+    ATTACH_AST_OPERATIONS(ErrorRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ///////////////////////////////
   // The Sass `@debug` directive.
   ///////////////////////////////
-  class Debug final : public Statement {
-    ADD_PROPERTY(Expression_Obj, value)
+  class DebugRule final : public Statement {
+    ADD_PROPERTY(ExpressionObj, value)
   public:
-    Debug(ParserState pstate, Expression_Obj val);
-    ATTACH_AST_OPERATIONS(Debug)
+    DebugRule(SourceSpan pstate, ExpressionObj val);
+    ATTACH_AST_OPERATIONS(DebugRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
@@ -694,7 +692,7 @@ namespace Sass {
     ADD_PROPERTY(String_Obj, text)
     ADD_PROPERTY(bool, is_important)
   public:
-    Comment(ParserState pstate, String_Obj txt, bool is_important);
+    Comment(SourceSpan pstate, String_Obj txt, bool is_important);
     virtual bool is_invisible() const override;
     ATTACH_AST_OPERATIONS(Comment)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -703,11 +701,11 @@ namespace Sass {
   ////////////////////////////////////
   // The Sass `@if` control directive.
   ////////////////////////////////////
-  class If final : public Has_Block {
-    ADD_PROPERTY(Expression_Obj, predicate)
+  class If final : public ParentStatement {
+    ADD_PROPERTY(ExpressionObj, predicate)
     ADD_PROPERTY(Block_Obj, alternative)
   public:
-    If(ParserState pstate, Expression_Obj pred, Block_Obj con, Block_Obj alt = {});
+    If(SourceSpan pstate, ExpressionObj pred, Block_Obj con, Block_Obj alt = {});
     virtual bool has_content() override;
     ATTACH_AST_OPERATIONS(If)
     ATTACH_CRTP_PERFORM_METHODS()
@@ -716,37 +714,37 @@ namespace Sass {
   /////////////////////////////////////
   // The Sass `@for` control directive.
   /////////////////////////////////////
-  class For final : public Has_Block {
-    ADD_CONSTREF(std::string, variable)
-    ADD_PROPERTY(Expression_Obj, lower_bound)
-    ADD_PROPERTY(Expression_Obj, upper_bound)
+  class ForRule final : public ParentStatement {
+    ADD_CONSTREF(sass::string, variable)
+    ADD_PROPERTY(ExpressionObj, lower_bound)
+    ADD_PROPERTY(ExpressionObj, upper_bound)
     ADD_PROPERTY(bool, is_inclusive)
   public:
-    For(ParserState pstate, std::string var, Expression_Obj lo, Expression_Obj hi, Block_Obj b, bool inc);
-    ATTACH_AST_OPERATIONS(For)
+    ForRule(SourceSpan pstate, sass::string var, ExpressionObj lo, ExpressionObj hi, Block_Obj b, bool inc);
+    ATTACH_AST_OPERATIONS(ForRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   //////////////////////////////////////
   // The Sass `@each` control directive.
   //////////////////////////////////////
-  class Each final : public Has_Block {
-    ADD_PROPERTY(std::vector<std::string>, variables)
-    ADD_PROPERTY(Expression_Obj, list)
+  class EachRule final : public ParentStatement {
+    ADD_PROPERTY(sass::vector<sass::string>, variables)
+    ADD_PROPERTY(ExpressionObj, list)
   public:
-    Each(ParserState pstate, std::vector<std::string> vars, Expression_Obj lst, Block_Obj b);
-    ATTACH_AST_OPERATIONS(Each)
+    EachRule(SourceSpan pstate, sass::vector<sass::string> vars, ExpressionObj lst, Block_Obj b);
+    ATTACH_AST_OPERATIONS(EachRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
   ///////////////////////////////////////
   // The Sass `@while` control directive.
   ///////////////////////////////////////
-  class While final : public Has_Block {
-    ADD_PROPERTY(Expression_Obj, predicate)
+  class WhileRule final : public ParentStatement {
+    ADD_PROPERTY(ExpressionObj, predicate)
   public:
-    While(ParserState pstate, Expression_Obj pred, Block_Obj b);
-    ATTACH_AST_OPERATIONS(While)
+    WhileRule(SourceSpan pstate, ExpressionObj pred, Block_Obj b);
+    ATTACH_AST_OPERATIONS(WhileRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
@@ -754,9 +752,9 @@ namespace Sass {
   // The @return directive for use inside SassScript functions.
   /////////////////////////////////////////////////////////////
   class Return final : public Statement {
-    ADD_PROPERTY(Expression_Obj, value)
+    ADD_PROPERTY(ExpressionObj, value)
   public:
-    Return(ParserState pstate, Expression_Obj val);
+    Return(SourceSpan pstate, ExpressionObj val);
     ATTACH_AST_OPERATIONS(Return)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -765,10 +763,10 @@ namespace Sass {
   // Definitions for both mixins and functions. The two cases are distinguished
   // by a type tag.
   /////////////////////////////////////////////////////////////////////////////
-  class Definition final : public Has_Block {
+  class Definition final : public ParentStatement {
   public:
     enum Type { MIXIN, FUNCTION };
-    ADD_CONSTREF(std::string, name)
+    ADD_CONSTREF(sass::string, name)
     ADD_PROPERTY(Parameters_Obj, parameters)
     ADD_PROPERTY(Env*, environment)
     ADD_PROPERTY(Type, type)
@@ -778,20 +776,20 @@ namespace Sass {
     ADD_PROPERTY(bool, is_overload_stub)
     ADD_PROPERTY(Signature, signature)
   public:
-    Definition(ParserState pstate,
-               std::string n,
+    Definition(SourceSpan pstate,
+               sass::string n,
                Parameters_Obj params,
                Block_Obj b,
                Type t);
-    Definition(ParserState pstate,
+    Definition(SourceSpan pstate,
                Signature sig,
-               std::string n,
+               sass::string n,
                Parameters_Obj params,
                Native_Function func_ptr,
                bool overload_stub = false);
-    Definition(ParserState pstate,
+    Definition(SourceSpan pstate,
                Signature sig,
-               std::string n,
+               sass::string n,
                Parameters_Obj params,
                Sass_Function_Entry c_func);
     ATTACH_AST_OPERATIONS(Definition)
@@ -801,12 +799,12 @@ namespace Sass {
   //////////////////////////////////////
   // Mixin calls (i.e., `@include ...`).
   //////////////////////////////////////
-  class Mixin_Call final : public Has_Block {
-    ADD_CONSTREF(std::string, name)
+  class Mixin_Call final : public ParentStatement {
+    ADD_CONSTREF(sass::string, name)
     ADD_PROPERTY(Arguments_Obj, arguments)
     ADD_PROPERTY(Parameters_Obj, block_parameters)
   public:
-    Mixin_Call(ParserState pstate, std::string n, Arguments_Obj args, Parameters_Obj b_params = {}, Block_Obj b = {});
+    Mixin_Call(SourceSpan pstate, sass::string n, Arguments_Obj args, Parameters_Obj b_params = {}, Block_Obj b = {});
     ATTACH_AST_OPERATIONS(Mixin_Call)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -817,7 +815,7 @@ namespace Sass {
   class Content final : public Statement {
     ADD_PROPERTY(Arguments_Obj, arguments)
   public:
-    Content(ParserState pstate, Arguments_Obj args);
+    Content(SourceSpan pstate, Arguments_Obj args);
     ATTACH_AST_OPERATIONS(Content)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -830,11 +828,11 @@ namespace Sass {
     enum Type { PLUS, MINUS, NOT, SLASH };
   private:
     HASH_PROPERTY(Type, optype)
-    HASH_PROPERTY(Expression_Obj, operand)
+    HASH_PROPERTY(ExpressionObj, operand)
     mutable size_t hash_;
   public:
-    Unary_Expression(ParserState pstate, Type t, Expression_Obj o);
-    const std::string type_name();
+    Unary_Expression(SourceSpan pstate, Type t, ExpressionObj o);
+    const sass::string type_name();
     virtual bool operator==(const Expression& rhs) const override;
     size_t hash() const override;
     ATTACH_AST_OPERATIONS(Unary_Expression)
@@ -845,13 +843,13 @@ namespace Sass {
   // Individual argument objects for mixin and function calls.
   ////////////////////////////////////////////////////////////
   class Argument final : public Expression {
-    HASH_PROPERTY(Expression_Obj, value)
-    HASH_CONSTREF(std::string, name)
+    HASH_PROPERTY(ExpressionObj, value)
+    HASH_CONSTREF(sass::string, name)
     ADD_PROPERTY(bool, is_rest_argument)
     ADD_PROPERTY(bool, is_keyword_argument)
     mutable size_t hash_;
   public:
-    Argument(ParserState pstate, Expression_Obj val, std::string n = "", bool rest = false, bool keyword = false);
+    Argument(SourceSpan pstate, ExpressionObj val, sass::string n = "", bool rest = false, bool keyword = false);
     void set_delayed(bool delayed) override;
     bool operator==(const Expression& rhs) const override;
     size_t hash() const override;
@@ -871,7 +869,7 @@ namespace Sass {
   protected:
     void adjust_after_pushing(Argument_Obj a) override;
   public:
-    Arguments(ParserState pstate);
+    Arguments(SourceSpan pstate);
     void set_delayed(bool delayed) override;
     Argument_Obj get_rest_argument();
     Argument_Obj get_keyword_argument();
@@ -880,12 +878,12 @@ namespace Sass {
   };
 
 
-  // A Media Ruleset before it has been evaluated
+  // A Media StyleRule before it has been evaluated
   // Could be already final or an interpolation
-  class MediaRule final : public Has_Block {
+  class MediaRule final : public ParentStatement {
     ADD_PROPERTY(List_Obj, schema)
   public:
-    MediaRule(ParserState pstate, Block_Obj block = {});
+    MediaRule(SourceSpan pstate, Block_Obj block = {});
 
     bool bubbles() override { return true; };
     bool is_invisible() const override { return false; };
@@ -893,12 +891,12 @@ namespace Sass {
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
-  // A Media Ruleset after it has been evaluated
+  // A Media StyleRule after it has been evaluated
   // Representing the static or resulting css
-  class CssMediaRule final : public Has_Block,
+  class CssMediaRule final : public ParentStatement,
     public Vectorized<CssMediaQuery_Obj> {
   public:
-    CssMediaRule(ParserState pstate, Block_Obj b);
+    CssMediaRule(SourceSpan pstate, Block_Obj b);
     bool bubbles() override { return true; };
     bool isInvisible() const { return empty(); }
     bool is_invisible() const override { return false; };
@@ -925,17 +923,17 @@ namespace Sass {
 
     // The modifier, probably either "not" or "only".
     // This may be `null` if no modifier is in use.
-    ADD_PROPERTY(std::string, modifier);
+    ADD_PROPERTY(sass::string, modifier);
 
     // The media type, for example "screen" or "print".
     // This may be `null`. If so, [features] will not be empty.
-    ADD_PROPERTY(std::string, type);
+    ADD_PROPERTY(sass::string, type);
 
     // Feature queries, including parentheses.
-    ADD_PROPERTY(std::vector<std::string>, features);
+    ADD_PROPERTY(sass::vector<sass::string>, features);
 
   public:
-    CssMediaQuery(ParserState pstate);
+    CssMediaQuery(SourceSpan pstate);
 
     // Check if two instances are considered equal
     bool operator== (const CssMediaQuery& rhs) const;
@@ -970,12 +968,12 @@ namespace Sass {
   // ToDo: only used for interpolation case
   ////////////////////////////////////////////////////
   class Media_Query final : public Expression,
-                            public Vectorized<Media_Query_Expression_Obj> {
+                            public Vectorized<Media_Query_ExpressionObj> {
     ADD_PROPERTY(String_Obj, media_type)
     ADD_PROPERTY(bool, is_negated)
     ADD_PROPERTY(bool, is_restricted)
   public:
-    Media_Query(ParserState pstate, String_Obj t = {}, size_t s = 0, bool n = false, bool r = false);
+    Media_Query(SourceSpan pstate, String_Obj t = {}, size_t s = 0, bool n = false, bool r = false);
     ATTACH_AST_OPERATIONS(Media_Query)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -985,11 +983,11 @@ namespace Sass {
   // ToDo: only used for interpolation case
   ////////////////////////////////////////////////////
   class Media_Query_Expression final : public Expression {
-    ADD_PROPERTY(Expression_Obj, feature)
-    ADD_PROPERTY(Expression_Obj, value)
+    ADD_PROPERTY(ExpressionObj, feature)
+    ADD_PROPERTY(ExpressionObj, value)
     ADD_PROPERTY(bool, is_interpolated)
   public:
-    Media_Query_Expression(ParserState pstate, Expression_Obj f, Expression_Obj v, bool i = false);
+    Media_Query_Expression(SourceSpan pstate, ExpressionObj f, ExpressionObj v, bool i = false);
     ATTACH_AST_OPERATIONS(Media_Query_Expression)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -999,11 +997,11 @@ namespace Sass {
   /////////////////////////////////////////////////
   class At_Root_Query final : public Expression {
   private:
-    ADD_PROPERTY(Expression_Obj, feature)
-    ADD_PROPERTY(Expression_Obj, value)
+    ADD_PROPERTY(ExpressionObj, feature)
+    ADD_PROPERTY(ExpressionObj, value)
   public:
-    At_Root_Query(ParserState pstate, Expression_Obj f = {}, Expression_Obj v = {}, bool i = false);
-    bool exclude(std::string str);
+    At_Root_Query(SourceSpan pstate, ExpressionObj f = {}, ExpressionObj v = {}, bool i = false);
+    bool exclude(sass::string str);
     ATTACH_AST_OPERATIONS(At_Root_Query)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -1011,13 +1009,13 @@ namespace Sass {
   ///////////
   // At-root.
   ///////////
-  class At_Root_Block final : public Has_Block {
+  class AtRootRule final : public ParentStatement {
     ADD_PROPERTY(At_Root_Query_Obj, expression)
   public:
-    At_Root_Block(ParserState pstate, Block_Obj b = {}, At_Root_Query_Obj e = {});
+    AtRootRule(SourceSpan pstate, Block_Obj b = {}, At_Root_Query_Obj e = {});
     bool bubbles() override;
     bool exclude_node(Statement_Obj s);
-    ATTACH_AST_OPERATIONS(At_Root_Block)
+    ATTACH_AST_OPERATIONS(AtRootRule)
     ATTACH_CRTP_PERFORM_METHODS()
   };
 
@@ -1025,11 +1023,11 @@ namespace Sass {
   // Individual parameter objects for mixins and functions.
   /////////////////////////////////////////////////////////
   class Parameter final : public AST_Node {
-    ADD_CONSTREF(std::string, name)
-    ADD_PROPERTY(Expression_Obj, default_value)
+    ADD_CONSTREF(sass::string, name)
+    ADD_PROPERTY(ExpressionObj, default_value)
     ADD_PROPERTY(bool, is_rest_parameter)
   public:
-    Parameter(ParserState pstate, std::string n, Expression_Obj def = {}, bool rest = false);
+    Parameter(SourceSpan pstate, sass::string n, ExpressionObj def = {}, bool rest = false);
     ATTACH_AST_OPERATIONS(Parameter)
     ATTACH_CRTP_PERFORM_METHODS()
   };
@@ -1045,7 +1043,7 @@ namespace Sass {
   protected:
     void adjust_after_pushing(Parameter_Obj p) override;
   public:
-    Parameters(ParserState pstate);
+    Parameters(SourceSpan pstate);
     ATTACH_AST_OPERATIONS(Parameters)
     ATTACH_CRTP_PERFORM_METHODS()
   };