sassc 1.8.3 → 1.8.4

data/ext/libsass/src/ast.hpp

@@ -44,15 +44,29 @@
 #include "error_handling.hpp"
 #include "ast_def_macros.hpp"
 #include "ast_fwd_decl.hpp"
-#include "to_string.hpp"
 #include "source_map.hpp"
 
 #include "sass.h"
 
 namespace Sass {
 
+  // ToDo: should this really be hardcoded
+  // Note: most methods follow precision option
   const double NUMBER_EPSILON = 0.00000000000001;
 
+  // ToDo: where does this fit best?
+  // We don't share this with C-API?
+  class Operand {
+    public:
+      Operand(Sass_OP operand, bool ws_before = false, bool ws_after = false)
+      : operand(operand), ws_before(ws_before), ws_after(ws_after)
+      { }
+    public:
+      enum Sass_OP operand;
+      bool ws_before;
+      bool ws_after;
+  };
+
   // from boost (functional/hash):
   // http://www.boost.org/doc/libs/1_35_0/doc/html/hash/combine.html
   // Boost Software License - Version 1.0
@@ -74,6 +88,11 @@ namespace Sass {
     : pstate_(pstate)
     { }
     virtual ~AST_Node() = 0;
+    virtual size_t hash() { 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_string() const;
     // virtual Block* block() { return 0; }
   public:
     void update_pstate(const ParserState& pstate);
@@ -129,9 +148,26 @@ namespace Sass {
     virtual bool is_false() { return false; }
     virtual bool operator== (const Expression& rhs) const { return false; }
     virtual void set_delayed(bool delayed) { is_delayed(delayed); }
+    virtual bool has_interpolant() const { return is_interpolant(); }
+    virtual bool is_left_interpolant() const { return is_interpolant(); }
+    virtual bool is_right_interpolant() const { return is_interpolant(); }
+    virtual std::string inspect() const { return to_string({ INSPECT, 5 }); }
+    virtual std::string to_sass() const { return to_string({ TO_SASS, 5 }); }
     virtual size_t hash() { return 0; }
   };
 
+  //////////////////////////////////////////////////////////////////////
+  // Still just an expression, but with a to_string method
+  //////////////////////////////////////////////////////////////////////
+  class PreValue : public Expression {
+  public:
+    PreValue(ParserState pstate,
+               bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)
+    : Expression(pstate, d, e, i, ct)
+    { }
+    virtual ~PreValue() { }
+  };
+
   //////////////////////////////////////////////////////////////////////
   // base class for values that support operations
   //////////////////////////////////////////////////////////////////////
@@ -142,7 +178,6 @@ namespace Sass {
     : Expression(pstate, d, e, i, ct)
     { }
     virtual bool operator== (const Expression& rhs) const = 0;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const = 0;
   };
 }
 
@@ -189,8 +224,8 @@ namespace Sass {
     virtual ~Vectorized() = 0;
     size_t length() const   { return elements_.size(); }
     bool empty() const      { return elements_.empty(); }
-    T last()                { return elements_.back(); }
-    T first()               { return elements_.front(); }
+    T last() const          { return elements_.back(); }
+    T first() const         { return elements_.front(); }
     T& operator[](size_t i) { return elements_[i]; }
     virtual const T& at(size_t i) const { return elements_.at(i); }
     const T& operator[](size_t i) const { return elements_[i]; }
@@ -216,6 +251,16 @@ namespace Sass {
     const std::vector<T>& elements() const { return elements_; }
     std::vector<T>& elements(std::vector<T>& e) { elements_ = e; return elements_; }
 
+    virtual size_t hash()
+    {
+      if (hash_ == 0) {
+        for (T& el : elements_) {
+          hash_combine(hash_, el->hash());
+        }
+      }
+      return hash_;
+    }
+
     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(); }
@@ -820,8 +865,8 @@ namespace Sass {
     std::string type() { return is_arglist_ ? "arglist" : "list"; }
     static std::string type_name() { return "list"; }
     const char* sep_string(bool compressed = false) const {
-      return separator() == SASS_COMMA ?
-        (compressed ? "," : ", ") : " ";
+      return separator() == SASS_SPACE ?
+        " " : (compressed ? "," : ", ");
     }
     bool is_invisible() const { return empty(); }
     Expression* value_at_index(size_t i);
@@ -846,7 +891,6 @@ namespace Sass {
     }
 
     virtual bool operator== (const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
 
     ATTACH_OPERATIONS()
   };
@@ -879,29 +923,49 @@ namespace Sass {
     }
 
     virtual bool operator== (const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
 
     ATTACH_OPERATIONS()
   };
 
+  inline static const std::string sass_op_to_name(enum Sass_OP op) {
+    switch (op) {
+      case AND: return "and"; break;
+      case OR: return "or"; break;
+      case EQ: return "eq"; break;
+      case NEQ: return "neq"; break;
+      case GT: return "gt"; break;
+      case GTE: return "gte"; break;
+      case LT: return "lt"; break;
+      case LTE: return "lte"; break;
+      case ADD: return "plus"; break;
+      case SUB: return "sub"; break;
+      case MUL: return "times"; break;
+      case DIV: return "div"; break;
+      case MOD: return "mod"; break;
+      // this is only used internally!
+      case NUM_OPS: return "[OPS]"; break;
+      default: return "invalid"; break;
+    }
+  }
+
   //////////////////////////////////////////////////////////////////////////
   // Binary expressions. Represents logical, relational, and arithmetic
   // operations. Templatized to avoid large switch statements and repetitive
   // subclassing.
   //////////////////////////////////////////////////////////////////////////
-  class Binary_Expression : public Expression {
+  class Binary_Expression : public PreValue {
   private:
-    ADD_HASHED(enum Sass_OP, type)
+    ADD_HASHED(Operand, op)
     ADD_HASHED(Expression*, left)
     ADD_HASHED(Expression*, right)
     size_t hash_;
   public:
     Binary_Expression(ParserState pstate,
-                      enum Sass_OP t, Expression* lhs, Expression* rhs)
-    : Expression(pstate), type_(t), left_(lhs), right_(rhs), hash_(0)
+                      Operand op, Expression* lhs, Expression* rhs)
+    : PreValue(pstate), op_(op), left_(lhs), right_(rhs), hash_(0)
     { }
     const std::string type_name() {
-      switch (type_) {
+      switch (type()) {
         case AND: return "and"; break;
         case OR: return "or"; break;
         case EQ: return "eq"; break;
@@ -915,10 +979,38 @@ namespace Sass {
         case MUL: return "mul"; break;
         case DIV: return "div"; break;
         case MOD: return "mod"; break;
-        case NUM_OPS: return "num_ops"; break;
+        // this is only used internally!
+        case NUM_OPS: return "[OPS]"; break;
+        default: return "invalid"; break;
+      }
+    }
+    const std::string separator() {
+      switch (type()) {
+        case AND: return "&&"; break;
+        case OR: return "||"; break;
+        case EQ: return "=="; break;
+        case NEQ: return "!="; break;
+        case GT: return ">"; break;
+        case GTE: return ">="; break;
+        case LT: return "<"; break;
+        case LTE: return "<="; break;
+        case ADD: return "+"; break;
+        case SUB: return "-"; break;
+        case MUL: return "*"; break;
+        case DIV: return "/"; break;
+        case MOD: return "%"; break;
+        // this is only used internally!
+        case NUM_OPS: return "[OPS]"; break;
         default: return "invalid"; break;
       }
     }
+    bool is_left_interpolant(void) const;
+    bool is_right_interpolant(void) const;
+    bool has_interpolant() const
+    {
+      return is_left_interpolant() ||
+             is_right_interpolant();
+    }
     virtual void set_delayed(bool delayed)
     {
       right()->set_delayed(delayed);
@@ -944,12 +1036,13 @@ namespace Sass {
     virtual size_t hash()
     {
       if (hash_ == 0) {
-        hash_ = std::hash<size_t>()(type_);
+        hash_ = std::hash<size_t>()(type());
         hash_combine(hash_, left()->hash());
         hash_combine(hash_, right()->hash());
       }
       return hash_;
     }
+    enum Sass_OP type() const { return op_.operand; }
     ATTACH_OPERATIONS()
   };
 
@@ -1065,23 +1158,27 @@ namespace Sass {
       has_rest_argument_(false),
       has_keyword_argument_(false)
     { }
+
+    Argument* get_rest_argument();
+    Argument* get_keyword_argument();
+
     ATTACH_OPERATIONS()
   };
 
   //////////////////
   // Function calls.
   //////////////////
-  class Function_Call : public Expression {
+  class Function_Call : public PreValue {
     ADD_HASHED(std::string, name)
     ADD_HASHED(Arguments*, arguments)
     ADD_PROPERTY(void*, cookie)
     size_t hash_;
   public:
     Function_Call(ParserState pstate, std::string n, Arguments* args, void* cookie)
-    : Expression(pstate), name_(n), arguments_(args), cookie_(cookie), hash_(0)
+    : PreValue(pstate), name_(n), arguments_(args), cookie_(cookie), hash_(0)
     { concrete_type(STRING); }
     Function_Call(ParserState pstate, std::string n, Arguments* args)
-    : Expression(pstate), name_(n), arguments_(args), cookie_(0), hash_(0)
+    : PreValue(pstate), name_(n), arguments_(args), cookie_(0), hash_(0)
     { concrete_type(STRING); }
 
     virtual bool operator==(const Expression& rhs) const
@@ -1131,11 +1228,11 @@ namespace Sass {
   ///////////////////////
   // Variable references.
   ///////////////////////
-  class Variable : public Expression {
+  class Variable : public PreValue {
     ADD_PROPERTY(std::string, name)
   public:
     Variable(ParserState pstate, std::string n)
-    : Expression(pstate), name_(n)
+    : PreValue(pstate), name_(n)
     { }
 
     virtual bool operator==(const Expression& rhs) const
@@ -1214,7 +1311,8 @@ namespace Sass {
     size_t hash_;
   public:
     Number(ParserState pstate, double val, std::string u = "", bool zero = true);
-    bool            zero()              { return zero_; }
+    bool zero() { return zero_; }
+    bool is_valid_css_unit() const;
     std::vector<std::string>& numerator_units()   { return numerator_units_; }
     std::vector<std::string>& denominator_units() { return denominator_units_; }
     const std::vector<std::string>& numerator_units() const   { return numerator_units_; }
@@ -1223,8 +1321,9 @@ namespace Sass {
     static std::string type_name() { return "number"; }
     std::string unit() const;
 
-    bool is_unitless();
-    void convert(const std::string& unit = "", bool strict = false);
+    bool is_unitless() const;
+    double convert_factor(const Number&) const;
+    bool convert(const std::string& unit = "", bool strict = false);
     void normalize(const std::string& unit = "", bool strict = false);
     // useful for making one number compatible with another
     std::string find_convertible_unit() const;
@@ -1243,7 +1342,6 @@ namespace Sass {
 
     virtual bool operator< (const Number& rhs) const;
     virtual bool operator== (const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
 
     ATTACH_OPERATIONS()
   };
@@ -1256,12 +1354,11 @@ namespace Sass {
     ADD_HASHED(double, g)
     ADD_HASHED(double, b)
     ADD_HASHED(double, a)
-    ADD_PROPERTY(bool, sixtuplet)
     ADD_PROPERTY(std::string, disp)
     size_t hash_;
   public:
-    Color(ParserState pstate, double r, double g, double b, double a = 1, bool sixtuplet = true, const std::string disp = "")
-    : Value(pstate), r_(r), g_(g), b_(b), a_(a), sixtuplet_(sixtuplet), disp_(disp),
+    Color(ParserState pstate, double r, double g, double b, double a = 1, const std::string disp = "")
+    : Value(pstate), r_(r), g_(g), b_(b), a_(a), disp_(disp),
       hash_(0)
     { concrete_type(COLOR); }
     std::string type() { return "color"; }
@@ -1279,7 +1376,6 @@ namespace Sass {
     }
 
     virtual bool operator== (const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
 
     ATTACH_OPERATIONS()
   };
@@ -1294,7 +1390,6 @@ namespace Sass {
     : Value(pstate), message_(msg)
     { concrete_type(C_ERROR); }
     virtual bool operator== (const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -1308,7 +1403,6 @@ namespace Sass {
     : Value(pstate), message_(msg)
     { concrete_type(C_WARNING); }
     virtual bool operator== (const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -1337,7 +1431,6 @@ namespace Sass {
     }
 
     virtual bool operator== (const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
 
     ATTACH_OPERATIONS()
   };
@@ -1355,7 +1448,6 @@ namespace Sass {
     static std::string type_name() { return "string"; }
     virtual ~String() = 0;
     virtual bool operator==(const Expression& rhs) const = 0;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const = 0;
     ATTACH_OPERATIONS()
   };
   inline String::~String() { };
@@ -1365,15 +1457,25 @@ namespace Sass {
   // evaluation phase.
   ///////////////////////////////////////////////////////////////////////
   class String_Schema : public String, public Vectorized<Expression*> {
-    ADD_PROPERTY(bool, has_interpolants)
+    // ADD_PROPERTY(bool, has_interpolants)
     size_t hash_;
   public:
     String_Schema(ParserState pstate, size_t size = 0, bool has_interpolants = false)
-    : String(pstate), Vectorized<Expression*>(size), has_interpolants_(has_interpolants), hash_(0)
+    : String(pstate), Vectorized<Expression*>(size), hash_(0)
     { concrete_type(STRING); }
     std::string type() { return "string"; }
     static std::string type_name() { return "string"; }
 
+    bool is_left_interpolant(void) const;
+    bool is_right_interpolant(void) const;
+    // void has_interpolants(bool tc) { }
+    bool has_interpolants() {
+      for (auto el : elements()) {
+        if (el->is_interpolant()) return true;
+      }
+      return false;
+    }
+
     virtual size_t hash()
     {
       if (hash_ == 0) {
@@ -1384,7 +1486,6 @@ namespace Sass {
     }
 
     virtual bool operator==(const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
 
     ATTACH_OPERATIONS()
   };
@@ -1423,7 +1524,7 @@ namespace Sass {
     }
 
     virtual bool operator==(const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
+    virtual std::string inspect() const; // quotes are forced on inspection
 
     // static char auto_quote() { return '*'; }
     static char double_quote() { return '"'; }
@@ -1444,7 +1545,7 @@ namespace Sass {
       if (q && quote_mark_) quote_mark_ = q;
     }
     virtual bool operator==(const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
+    virtual std::string inspect() const; // quotes are forced on inspection
     ATTACH_OPERATIONS()
   };
 
@@ -1581,8 +1682,7 @@ namespace Sass {
     { }
     bool exclude(std::string str)
     {
-      To_String to_string;
-      bool with = feature() && unquote(feature()->perform(&to_string)).compare("with") == 0;
+      bool with = feature() && unquote(feature()->to_string()).compare("with") == 0;
       List* l = static_cast<List*>(value());
       std::string v;
 
@@ -1591,7 +1691,7 @@ namespace Sass {
         if (!l || l->length() == 0) return str.compare("rule") != 0;
         for (size_t i = 0, L = l->length(); i < L; ++i)
         {
-          v = unquote((*l)[i]->perform(&to_string));
+          v = unquote((*l)[i]->to_string());
           if (v.compare("all") == 0 || v == str) return false;
         }
         return true;
@@ -1601,7 +1701,7 @@ namespace Sass {
         if (!l || !l->length()) return str.compare("rule") == 0;
         for (size_t i = 0, L = l->length(); i < L; ++i)
         {
-          v = unquote((*l)[i]->perform(&to_string));
+          v = unquote((*l)[i]->to_string());
           if (v.compare("all") == 0 || v == str) return true;
         }
         return false;
@@ -1665,7 +1765,6 @@ namespace Sass {
     }
 
     virtual bool operator== (const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
 
     ATTACH_OPERATIONS()
   };
@@ -1747,7 +1846,7 @@ namespace Sass {
   // Abstract base class for CSS selectors.
   /////////////////////////////////////////
   class Selector : public Expression {
-    ADD_PROPERTY(bool, has_reference)
+    // ADD_PROPERTY(bool, has_reference)
     ADD_PROPERTY(bool, has_placeholder)
     // line break before list separator
     ADD_PROPERTY(bool, has_line_feed)
@@ -1757,21 +1856,27 @@ namespace Sass {
     ADD_PROPERTY(bool, is_optional)
     // parent block pointers
     ADD_PROPERTY(Media_Block*, media_block)
+  protected:
+    size_t hash_;
   public:
     Selector(ParserState pstate, bool r = false, bool h = false)
     : Expression(pstate),
-      has_reference_(r),
+      // has_reference_(r),
       has_placeholder_(h),
       has_line_feed_(false),
       has_line_break_(false),
       is_optional_(false),
-      media_block_(0)
+      media_block_(0),
+      hash_(0)
     { concrete_type(SELECTOR); }
     virtual ~Selector() = 0;
+    virtual size_t hash() = 0;
+    virtual bool has_parent_ref() {
+      return false;
+    }
     virtual unsigned long specificity() {
       return Constants::Specificity_Universal;
     }
-    virtual std::string to_string(bool compressed = false, int precision = 5) const = 0;
   };
   inline Selector::~Selector() { }
 
@@ -1786,7 +1891,12 @@ namespace Sass {
     Selector_Schema(ParserState pstate, String* c)
     : Selector(pstate), contents_(c), at_root_(false)
     { }
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
+    virtual size_t hash() {
+      if (hash_ == 0) {
+        hash_combine(hash_, contents_->hash());
+      }
+      return hash_;
+    }
     ATTACH_OPERATIONS()
   };
 
@@ -1816,6 +1926,15 @@ namespace Sass {
         name += ns_ + "|";
       return name + name_;
     }
+    virtual size_t hash()
+    {
+      if (hash_ == 0) {
+        hash_combine(hash_, std::hash<int>()(SELECTOR));
+        hash_combine(hash_, std::hash<std::string>()(ns()));
+        hash_combine(hash_, std::hash<std::string>()(name()));
+      }
+      return hash_;
+    }
     // namespace query functions
     bool is_universal_ns() const
     {
@@ -1856,7 +1975,6 @@ namespace Sass {
 
     bool operator<(const Simple_Selector& rhs) const;
     // default implementation should work for most of the simple selectors (otherwise overload)
-    virtual std::string to_string(bool compressed = false, int precision = 5) const { return this->ns_name(); };
     ATTACH_OPERATIONS();
   };
   inline Simple_Selector::~Simple_Selector() { }
@@ -1872,7 +1990,7 @@ namespace Sass {
   public:
     Parent_Selector(ParserState pstate)
     : Simple_Selector(pstate, "&")
-    { has_reference(true); }
+    { /* has_reference(true); */ }
     virtual bool has_parent_ref() { return true; };
     virtual unsigned long specificity()
     {
@@ -1880,7 +1998,6 @@ namespace Sass {
     }
     std::string type() { return "selector"; }
     static std::string type_name() { return "selector"; }
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -1944,6 +2061,15 @@ namespace Sass {
     Attribute_Selector(ParserState pstate, std::string n, std::string m, String* v)
     : Simple_Selector(pstate, n), matcher_(m), value_(v)
     { }
+    virtual size_t hash()
+    {
+      if (hash_ == 0) {
+        hash_combine(hash_, Simple_Selector::hash());
+        hash_combine(hash_, std::hash<std::string>()(matcher()));
+        if (value_) hash_combine(hash_, value_->hash());
+      }
+      return hash_;
+    }
     virtual unsigned long specificity()
     {
       return Constants::Specificity_Attr;
@@ -1952,7 +2078,6 @@ namespace Sass {
     bool operator==(const Attribute_Selector& rhs) const;
     bool operator<(const Simple_Selector& rhs) const;
     bool operator<(const Attribute_Selector& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -1971,6 +2096,7 @@ namespace Sass {
            name == ":first-letter";
   }
 
+  // Pseudo Selector cannot have any namespace?
   class Pseudo_Selector : public Simple_Selector {
     ADD_PROPERTY(String*, expression)
   public:
@@ -1999,6 +2125,14 @@ namespace Sass {
       return (name_[0] == ':' && name_[1] == ':')
              || is_pseudo_class_element(name_);
     }
+    virtual size_t hash()
+    {
+      if (hash_ == 0) {
+        hash_combine(hash_, Simple_Selector::hash());
+        if (expression_) hash_combine(hash_, expression_->hash());
+      }
+      return hash_;
+    }
     virtual unsigned long specificity()
     {
       if (is_pseudo_element())
@@ -2018,16 +2152,30 @@ namespace Sass {
     Wrapped_Selector(ParserState pstate, std::string n, Selector* sel)
     : Simple_Selector(pstate, n), selector_(sel)
     { }
+    virtual bool has_parent_ref() {
+      // if (has_reference()) return true;
+      if (!selector()) return false;
+      return selector()->has_parent_ref();
+    }
     virtual bool is_superselector_of(Wrapped_Selector* sub);
     // Selectors inside the negation pseudo-class are counted like any
     // other, but the negation itself does not count as a pseudo-class.
+    virtual size_t hash()
+    {
+      if (hash_ == 0) {
+        hash_combine(hash_, Simple_Selector::hash());
+        if (selector_) hash_combine(hash_, selector_->hash());
+      }
+      return hash_;
+    }
     virtual unsigned long specificity()
     {
       return selector_ ? selector_->specificity() : 0;
     }
     bool operator==(const Simple_Selector& rhs) const;
     bool operator==(const Wrapped_Selector& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
+    bool operator<(const Simple_Selector& rhs) const;
+    bool operator<(const Wrapped_Selector& rhs) const;
     ATTACH_OPERATIONS()
   };
 
@@ -2043,17 +2191,19 @@ namespace Sass {
   class Compound_Selector : public Selector, public Vectorized<Simple_Selector*> {
   private:
     SourcesSet sources_;
+    ADD_PROPERTY(bool, extended);
     ADD_PROPERTY(bool, has_parent_reference);
   protected:
     void adjust_after_pushing(Simple_Selector* s)
     {
-      if (s->has_reference())   has_reference(true);
+      // if (s->has_reference())   has_reference(true);
       if (s->has_placeholder()) has_placeholder(true);
     }
   public:
     Compound_Selector(ParserState pstate, size_t s = 0)
     : Selector(pstate),
       Vectorized<Simple_Selector*>(s),
+      extended_(false),
       has_parent_reference_(false)
     { }
     bool contains_placeholder() {
@@ -2079,14 +2229,22 @@ namespace Sass {
     }
     const Simple_Selector* base() const {
       if (length() == 0) return 0;
-      if (typeid(*(*this)[0]) == typeid(Type_Selector))
+      // ToDo: why is this needed?
+      if (dynamic_cast<Type_Selector*>((*this)[0]))
         return (*this)[0];
-//      else cerr << "SERIOUSELY " << "\n";
       return 0;
     }
     virtual bool is_superselector_of(Compound_Selector* sub, std::string wrapped = "");
     virtual bool is_superselector_of(Complex_Selector* sub, std::string wrapped = "");
     virtual bool is_superselector_of(Selector_List* sub, std::string wrapped = "");
+    virtual size_t hash()
+    {
+      if (Selector::hash_ == 0) {
+        hash_combine(Selector::hash_, std::hash<int>()(SELECTOR));
+        if (length()) hash_combine(Selector::hash_, Vectorized::hash());
+      }
+      return Selector::hash_;
+    }
     virtual unsigned long specificity()
     {
       int sum = 0;
@@ -2098,7 +2256,7 @@ namespace Sass {
     bool is_empty_reference()
     {
       return length() == 1 &&
-             typeid(*(*this)[0]) == typeid(Parent_Selector);
+             dynamic_cast<Parent_Selector*>((*this)[0]);
     }
     std::vector<std::string> to_str_vec(); // sometimes need to convert to a flat "by-value" data structure
 
@@ -2114,7 +2272,6 @@ namespace Sass {
     Compound_Selector* clone(Context&) const; // does not clone the Simple_Selector*s
 
     Compound_Selector* minus(Compound_Selector* rhs, Context& ctx);
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -2147,7 +2304,7 @@ namespace Sass {
       head_(h), tail_(t),
       reference_(r)
     {
-      if ((h && h->has_reference())   || (t && t->has_reference()))   has_reference(true);
+      // if ((h && h->has_reference())   || (t && t->has_reference()))   has_reference(true);
       if ((h && h->has_placeholder()) || (t && t->has_placeholder())) has_placeholder(true);
     }
     virtual bool has_parent_ref();
@@ -2202,6 +2359,16 @@ namespace Sass {
     Combinator clear_innermost();
     void append(Context&, Complex_Selector*);
     void set_innermost(Complex_Selector*, Combinator);
+    virtual size_t hash()
+    {
+      if (hash_ == 0) {
+        hash_combine(hash_, std::hash<int>()(SELECTOR));
+        hash_combine(hash_, std::hash<int>()(combinator_));
+        if (head_) hash_combine(hash_, head_->hash());
+        if (tail_) hash_combine(hash_, tail_->hash());
+      }
+      return hash_;
+    }
     virtual unsigned long specificity() const
     {
       int sum = 0;
@@ -2263,7 +2430,6 @@ namespace Sass {
     Complex_Selector* clone(Context&) const;      // does not clone Compound_Selector*s
     Complex_Selector* cloneFully(Context&) const; // clones Compound_Selector*s
     // std::vector<Compound_Selector*> to_vector();
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };
 
@@ -2284,6 +2450,7 @@ namespace Sass {
     std::string type() { return "list"; }
     // remove parent selector references
     // basically unwraps parsed selectors
+    virtual bool has_parent_ref();
     void remove_parent_selectors();
     // virtual Selector_Placeholder* find_placeholder();
     Selector_List* parentize(Selector_List* parents, Context& ctx);
@@ -2292,6 +2459,14 @@ namespace Sass {
     virtual bool is_superselector_of(Selector_List* sub, std::string wrapping = "");
     Selector_List* unify_with(Selector_List*, Context&);
     void populate_extends(Selector_List*, Context&, ExtensionSubsetMap&);
+    virtual size_t hash()
+    {
+      if (Selector::hash_ == 0) {
+        hash_combine(Selector::hash_, std::hash<int>()(SELECTOR));
+        hash_combine(Selector::hash_, Vectorized::hash());
+      }
+      return Selector::hash_;
+    }
     virtual unsigned long specificity()
     {
       unsigned long sum = 0;
@@ -2309,7 +2484,6 @@ namespace Sass {
     virtual bool operator==(const Selector_List& rhs) const;
     // Selector Lists can be compared to comma lists
     virtual bool operator==(const Expression& rhs) const;
-    virtual std::string to_string(bool compressed = false, int precision = 5) const;
     ATTACH_OPERATIONS()
   };