sassc 1.10.1 → 1.11.0

data/ext/libsass/src/ast.hpp

@@ -50,6 +50,9 @@
 
 namespace Sass {
 
+  // easier to search with name
+  const bool DELAYED = true;
+
   // ToDo: should this really be hardcoded
   // Note: most methods follow precision option
   const double NUMBER_EPSILON = 0.00000000000001;
@@ -67,7 +70,8 @@ namespace Sass {
       bool ws_after;
   };
 
-  // from boost (functional/hash):
+  //////////////////////////////////////////////////////////
+  // `hash_combine` comes from boost (functional/hash):
   // http://www.boost.org/doc/libs/1_35_0/doc/html/hash/combine.html
   // Boost Software License - Version 1.0
   // http://www.boost.org/users/license.html
@@ -77,6 +81,7 @@ namespace Sass {
     seed ^= std::hash<T>()(val) + 0x9e3779b9
              + (seed<<6) + (seed>>2);
   }
+  //////////////////////////////////////////////////////////
 
   //////////////////////////////////////////////////////////
   // Abstract base class for all abstract syntax tree nodes.
@@ -96,6 +101,7 @@ namespace Sass {
     // virtual Block* block() { return 0; }
   public:
     void update_pstate(const ParserState& pstate);
+    void set_pstate_offset(const Offset& offset);
   public:
     Offset off() { return pstate(); }
     Position pos() { return pstate(); }
@@ -136,7 +142,7 @@ namespace Sass {
                bool d = false, bool e = false, bool i = false, Concrete_Type ct = NONE)
     : AST_Node(pstate),
       is_delayed_(d),
-      is_expanded_(d),
+      is_expanded_(e),
       is_interpolant_(i),
       concrete_type_(ct)
     { }
@@ -147,6 +153,7 @@ namespace Sass {
     static std::string type_name() { return ""; }
     virtual bool is_false() { return false; }
     virtual bool operator== (const Expression& rhs) const { return false; }
+    virtual bool eq(const Expression& rhs) const { return *this == rhs; };
     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(); }
@@ -219,7 +226,7 @@ namespace Sass {
     void reset_hash() { hash_ = 0; }
     virtual void adjust_after_pushing(T element) { }
   public:
-    Vectorized(size_t s = 0) : elements_(std::vector<T>())
+    Vectorized(size_t s = 0) : elements_(std::vector<T>()), hash_(0)
     { elements_.reserve(s); }
     virtual ~Vectorized() = 0;
     size_t length() const   { return elements_.size(); }
@@ -229,7 +236,7 @@ namespace Sass {
     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]; }
-    Vectorized& operator<<(T element)
+    virtual Vectorized& operator<<(T element)
     {
       if (!element) return *this;
       reset_hash();
@@ -284,7 +291,7 @@ namespace Sass {
   };
   struct CompareExpression {
     bool operator()(const Expression* lhs, const Expression* rhs) const {
-      return lhs && rhs && *lhs == *rhs;
+      return lhs && rhs && lhs->eq(*rhs);
     }
   };
   typedef std::unordered_map<
@@ -391,11 +398,10 @@ namespace Sass {
     ADD_PROPERTY(bool, group_end)
   public:
     Statement(ParserState pstate, Statement_Type st = NONE, size_t t = 0)
-    : AST_Node(pstate), statement_type_(st), tabs_(t), group_end_(false)
+    : AST_Node(pstate), block_(0), statement_type_(st), tabs_(t), group_end_(false)
      { }
     virtual ~Statement() = 0;
     // needed for rearranging nested rulesets during CSS emission
-    virtual bool   is_hoistable() { return false; }
     virtual bool   is_invisible() const { return false; }
     virtual bool   bubbles() { return false; }
     virtual Block* block()  { return 0; }
@@ -413,22 +419,16 @@ namespace Sass {
     ADD_PROPERTY(bool, is_root)
     ADD_PROPERTY(bool, is_at_root);
     // needed for properly formatted CSS emission
-    ADD_PROPERTY(bool, has_hoistable)
-    ADD_PROPERTY(bool, has_non_hoistable)
   protected:
     void adjust_after_pushing(Statement* s)
     {
-      if (s->is_hoistable()) has_hoistable_     = true;
-      else                   has_non_hoistable_ = true;
     }
   public:
     Block(ParserState pstate, size_t s = 0, bool r = false)
     : Statement(pstate),
       Vectorized<Statement*>(s),
       is_root_(r),
-      is_at_root_(false),
-      has_hoistable_(false),
-      has_non_hoistable_(false)
+      is_at_root_(false)
     { }
     virtual bool has_content()
     {
@@ -471,20 +471,6 @@ namespace Sass {
     : Has_Block(pstate, b), selector_(s), at_root_(false), is_root_(false)
     { statement_type(RULESET); }
     bool is_invisible() const;
-    // nested rulesets need to be hoisted out of their enclosing blocks
-    bool is_hoistable() { return true; }
-    ATTACH_OPERATIONS()
-  };
-
-  /////////////////////////////////////////////////////////
-  // Nested declaration sets (i.e., namespaced properties).
-  /////////////////////////////////////////////////////////
-  class Propset : public Has_Block {
-    ADD_PROPERTY(String*, property_fragment)
-  public:
-    Propset(ParserState pstate, String* pf, Block* b = 0)
-    : Has_Block(pstate, b), property_fragment_(pf)
-    { }
     ATTACH_OPERATIONS()
   };
 
@@ -502,6 +488,18 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
+  /////////////////
+  // Trace.
+  /////////////////
+  class Trace : public Has_Block {
+    ADD_PROPERTY(std::string, name)
+  public:
+    Trace(ParserState pstate, std::string n, Block* b = 0)
+    : Has_Block(pstate, b), name_(n)
+    { }
+    ATTACH_OPERATIONS()
+  };
+
   /////////////////
   // Media queries.
   /////////////////
@@ -515,7 +513,6 @@ namespace Sass {
     : Has_Block(pstate, b), media_queries_(mqs)
     { statement_type(MEDIA); }
     bool bubbles() { return true; }
-    bool is_hoistable() { return true; }
     bool is_invisible() const;
     ATTACH_OPERATIONS()
   };
@@ -563,15 +560,15 @@ namespace Sass {
   ////////////////////////////////////////////////////////////////////////
   // Declarations -- style rules consisting of a property name and values.
   ////////////////////////////////////////////////////////////////////////
-  class Declaration : public Statement {
+  class Declaration : public Has_Block {
     ADD_PROPERTY(String*, property)
     ADD_PROPERTY(Expression*, value)
     ADD_PROPERTY(bool, is_important)
     ADD_PROPERTY(bool, is_indented)
   public:
     Declaration(ParserState pstate,
-                String* prop, Expression* val, bool i = false)
-    : Statement(pstate), property_(prop), value_(val), is_important_(i), is_indented_(false)
+                String* prop, Expression* val, bool i = false, Block* b = 0)
+    : Has_Block(pstate, b), property_(prop), value_(val), is_important_(i), is_indented_(false)
     { statement_type(DECLARATION); }
     ATTACH_OPERATIONS()
   };
@@ -770,7 +767,7 @@ namespace Sass {
   struct Backtrace;
   typedef Environment<AST_Node*> Env;
   typedef const char* Signature;
-  typedef Expression* (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtrace*);
+  typedef Expression* (*Native_Function)(Env&, Env&, Context&, Signature, ParserState, Backtrace*, std::vector<CommaSequence_Selector*>);
   typedef const char* Signature;
   class Definition : public Has_Block {
   public:
@@ -905,9 +902,8 @@ namespace Sass {
 
     virtual void set_delayed(bool delayed)
     {
-      for (size_t i = 0, L = length(); i < L; ++i)
-        (elements()[i])->set_delayed(delayed);
       is_delayed(delayed);
+      // don't set children
     }
 
     virtual bool operator== (const Expression& rhs) const;
@@ -929,6 +925,7 @@ namespace Sass {
     std::string type() { return "map"; }
     static std::string type_name() { return "map"; }
     bool is_invisible() const { return empty(); }
+    List* to_list(Context& ctx, ParserState& pstate);
 
     virtual size_t hash()
     {
@@ -1031,12 +1028,6 @@ namespace Sass {
       return is_left_interpolant() ||
              is_right_interpolant();
     }
-    virtual bool can_delay() const;
-    void reset_whitespace()
-    {
-      op_.ws_before = false;
-      op_.ws_after = false;
-    }
     virtual void set_delayed(bool delayed)
     {
       right()->set_delayed(delayed);
@@ -1138,6 +1129,7 @@ namespace Sass {
       }
     }
 
+    virtual void set_delayed(bool delayed);
     virtual bool operator==(const Expression& rhs) const
     {
       try
@@ -1185,6 +1177,8 @@ namespace Sass {
       has_keyword_argument_(false)
     { }
 
+    virtual void set_delayed(bool delayed);
+
     Argument* get_rest_argument();
     Argument* get_keyword_argument();
 
@@ -1296,7 +1290,7 @@ namespace Sass {
     size_t hash_;
   public:
     Textual(ParserState pstate, Type t, std::string val)
-    : Expression(pstate, true), type_(t), value_(val),
+    : Expression(pstate, DELAYED), type_(t), value_(val),
       hash_(0)
     { }
 
@@ -1368,6 +1362,7 @@ namespace Sass {
 
     virtual bool operator< (const Number& rhs) const;
     virtual bool operator== (const Expression& rhs) const;
+    virtual bool eq(const Expression& rhs) const;
 
     ATTACH_OPERATIONS()
   };
@@ -1466,10 +1461,9 @@ namespace Sass {
   // "flat" strings.
   ////////////////////////////////////////////////////////////////////////
   class String : public Value {
-    ADD_PROPERTY(bool, sass_fix_1291)
   public:
-    String(ParserState pstate, bool delayed = false, bool sass_fix_1291 = false)
-    : Value(pstate, delayed), sass_fix_1291_(sass_fix_1291)
+    String(ParserState pstate, bool delayed = false)
+    : Value(pstate, delayed)
     { concrete_type(STRING); }
     static std::string type_name() { return "string"; }
     virtual ~String() = 0;
@@ -1517,6 +1511,10 @@ namespace Sass {
       return hash_;
     }
 
+    virtual void set_delayed(bool delayed) {
+      is_delayed(delayed);
+    }
+
     virtual bool operator==(const Expression& rhs) const;
 
     ATTACH_OPERATIONS()
@@ -1574,10 +1572,14 @@ namespace Sass {
   ////////////////////////////////////////////////////////
   class String_Quoted : public String_Constant {
   public:
-    String_Quoted(ParserState pstate, std::string val, char q = 0, bool keep_utf8_escapes = false)
+    String_Quoted(ParserState pstate, std::string val, char q = 0,
+    	bool keep_utf8_escapes = false, bool skip_unquoting = false,
+    	bool strict_unquoting = true)
     : String_Constant(pstate, val)
     {
-      value_ = unquote(value_, &quote_mark_, keep_utf8_escapes);
+      if (skip_unquoting == false) {
+        value_ = unquote(value_, &quote_mark_, keep_utf8_escapes, strict_unquoting);
+      }
       if (q && quote_mark_) quote_mark_ = q;
     }
     virtual bool operator==(const Expression& rhs) const;
@@ -1626,7 +1628,6 @@ namespace Sass {
     Supports_Block(ParserState pstate, Supports_Condition* condition, Block* block = 0)
     : Has_Block(pstate, block), condition_(condition)
     { statement_type(SUPPORTS); }
-    bool is_hoistable() { return true; }
     bool bubbles() { return true; }
     ATTACH_OPERATIONS()
   };
@@ -1728,12 +1729,21 @@ namespace Sass {
     At_Root_Block(ParserState pstate, Block* b = 0, At_Root_Query* e = 0)
     : Has_Block(pstate, b), expression_(e)
     { statement_type(ATROOT); }
-    bool is_hoistable() { return true; }
     bool bubbles() { return true; }
     bool exclude_node(Statement* s) {
+      if (expression() == 0)
+      {
+        return s->statement_type() == Statement::RULESET;
+      }
+
       if (s->statement_type() == Statement::DIRECTIVE)
       {
-        return expression()->exclude(static_cast<Directive*>(s)->keyword().erase(0, 1));
+        if (Directive* dir = dynamic_cast<Directive*>(s))
+        {
+          std::string keyword(dir->keyword());
+          if (keyword.length() > 0) keyword.erase(0, 1);
+          return expression()->exclude(keyword);
+        }
       }
       if (s->statement_type() == Statement::MEDIA)
       {
@@ -1747,9 +1757,9 @@ namespace Sass {
       {
         return expression()->exclude("supports");
       }
-      if (static_cast<Directive*>(s)->is_keyframes())
+      if (Directive* dir = dynamic_cast<Directive*>(s))
       {
-        return expression()->exclude("keyframes");
+        if (dir->is_keyframes()) return expression()->exclude("keyframes");
       }
       return false;
     }
@@ -1856,7 +1866,6 @@ namespace Sass {
   /////////////////////////////////////////
   class Selector : public Expression {
     // ADD_PROPERTY(bool, has_reference)
-    ADD_PROPERTY(bool, has_placeholder)
     // line break before list separator
     ADD_PROPERTY(bool, has_line_feed)
     // line break after list separator
@@ -1871,7 +1880,6 @@ namespace Sass {
     Selector(ParserState pstate, bool r = false, bool h = false)
     : Expression(pstate),
       // has_reference_(r),
-      has_placeholder_(h),
       has_line_feed_(false),
       has_line_break_(false),
       is_optional_(false),
@@ -1880,15 +1888,24 @@ namespace Sass {
     { 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;
+      return 0;
     }
     virtual void set_media_block(Media_Block* mb) {
       media_block(mb);
     }
+    virtual bool has_wrapped_selector() {
+      return false;
+    }
+    virtual bool has_placeholder() {
+      return false;
+    }
+    virtual bool has_parent_ref() {
+      return false;
+    }
+    virtual bool has_real_parent_ref() {
+      return false;
+    }
   };
   inline Selector::~Selector() { }
 
@@ -1904,6 +1921,7 @@ namespace Sass {
     : Selector(pstate), contents_(c), at_root_(false)
     { }
     virtual bool has_parent_ref();
+    virtual bool has_real_parent_ref();
     virtual size_t hash() {
       if (hash_ == 0) {
         hash_combine(hash_, contents_->hash());
@@ -1932,6 +1950,10 @@ namespace Sass {
         name_ = n.substr(pos + 1);
       }
     }
+    virtual bool unique() const
+    {
+      return false;
+    }
     virtual std::string ns_name() const
     {
       std::string name("");
@@ -1976,12 +1998,13 @@ namespace Sass {
     }
 
     virtual ~Simple_Selector() = 0;
-    virtual Compound_Selector* unify_with(Compound_Selector*, Context&);
+    virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
     virtual bool has_parent_ref() { return false; };
+    virtual bool has_real_parent_ref() { return false; };
     virtual bool is_pseudo_element() { return false; }
     virtual bool is_pseudo_class() { return false; }
 
-    virtual bool is_superselector_of(Compound_Selector* sub) { return false; }
+    virtual bool is_superselector_of(SimpleSequence_Selector* sub) { return false; }
 
     bool operator==(const Simple_Selector& rhs) const;
     inline bool operator!=(const Simple_Selector& rhs) const { return !(*this == rhs); }
@@ -1997,14 +2020,17 @@ namespace Sass {
   // The Parent Selector Expression.
   //////////////////////////////////
   // parent selectors can occur in selectors but also
-  // inside strings in declarations (Compound_Selector).
+  // inside strings in declarations (SimpleSequence_Selector).
   // only one simple parent selector means the first case.
   class Parent_Selector : public Simple_Selector {
+    ADD_PROPERTY(bool, real)
   public:
-    Parent_Selector(ParserState pstate)
-    : Simple_Selector(pstate, "&")
+    Parent_Selector(ParserState pstate, bool r = true)
+    : Simple_Selector(pstate, "&"), real_(r)
     { /* has_reference(true); */ }
+    bool is_real_parent_ref() { return real(); };
     virtual bool has_parent_ref() { return true; };
+    virtual bool has_real_parent_ref() { return is_real_parent_ref(); };
     virtual unsigned long specificity()
     {
       return 0;
@@ -2017,50 +2043,78 @@ namespace Sass {
   /////////////////////////////////////////////////////////////////////////
   // Placeholder selectors (e.g., "%foo") for use in extend-only selectors.
   /////////////////////////////////////////////////////////////////////////
-  class Selector_Placeholder : public Simple_Selector {
+  class Placeholder_Selector : public Simple_Selector {
   public:
-    Selector_Placeholder(ParserState pstate, std::string n)
+    Placeholder_Selector(ParserState pstate, std::string n)
     : Simple_Selector(pstate, n)
-    { has_placeholder(true); }
-    // virtual Selector_Placeholder* find_placeholder();
-    virtual ~Selector_Placeholder() {};
+    { }
+    virtual unsigned long specificity()
+    {
+      return Constants::Specificity_Base;
+    }
+    virtual bool has_placeholder() {
+      return true;
+    }
+    // virtual Placeholder_Selector* find_placeholder();
+    virtual ~Placeholder_Selector() {};
     ATTACH_OPERATIONS()
   };
 
   /////////////////////////////////////////////////////////////////////
-  // Type selectors (and the universal selector) -- e.g., div, span, *.
+  // Element selectors (and the universal selector) -- e.g., div, span, *.
   /////////////////////////////////////////////////////////////////////
-  class Type_Selector : public Simple_Selector {
+  class Element_Selector : public Simple_Selector {
   public:
-    Type_Selector(ParserState pstate, std::string n)
+    Element_Selector(ParserState pstate, std::string n)
     : Simple_Selector(pstate, n)
     { }
     virtual unsigned long specificity()
     {
-      // ToDo: What is the specificity of the star selector?
-      if (name() == "*") return Constants::Specificity_Universal;
-      else               return Constants::Specificity_Type;
+      if (name() == "*") return 0;
+      else               return Constants::Specificity_Element;
     }
     virtual Simple_Selector* unify_with(Simple_Selector*, Context&);
-    virtual Compound_Selector* unify_with(Compound_Selector*, Context&);
+    virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
     ATTACH_OPERATIONS()
   };
 
   ////////////////////////////////////////////////
-  // Selector qualifiers -- i.e., classes and ids.
+  // Class selectors  -- i.e., .foo.
   ////////////////////////////////////////////////
-  class Selector_Qualifier : public Simple_Selector {
+  class Class_Selector : public Simple_Selector {
   public:
-    Selector_Qualifier(ParserState pstate, std::string n)
+    Class_Selector(ParserState pstate, std::string n)
     : Simple_Selector(pstate, n)
     { }
+    virtual bool unique() const
+    {
+      return false;
+    }
+    virtual unsigned long specificity()
+    {
+      return Constants::Specificity_Class;
+    }
+    virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
+    ATTACH_OPERATIONS()
+  };
+
+  ////////////////////////////////////////////////
+  // ID selectors -- i.e., #foo.
+  ////////////////////////////////////////////////
+  class Id_Selector : public Simple_Selector {
+  public:
+    Id_Selector(ParserState pstate, std::string n)
+    : Simple_Selector(pstate, n)
+    { }
+    virtual bool unique() const
+    {
+      return true;
+    }
     virtual unsigned long specificity()
     {
-      if (name()[0] == '#') return Constants::Specificity_ID;
-      if (name()[0] == '.') return Constants::Specificity_Class;
-      else                  return Constants::Specificity_Type;
+      return Constants::Specificity_ID;
     }
-    virtual Compound_Selector* unify_with(Compound_Selector*, Context&);
+    virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
     ATTACH_OPERATIONS()
   };
 
@@ -2149,14 +2203,14 @@ namespace Sass {
     virtual unsigned long specificity()
     {
       if (is_pseudo_element())
-        return Constants::Specificity_Type;
+        return Constants::Specificity_Element;
       return Constants::Specificity_Pseudo;
     }
     bool operator==(const Simple_Selector& rhs) const;
     bool operator==(const Pseudo_Selector& rhs) const;
     bool operator<(const Simple_Selector& rhs) const;
     bool operator<(const Pseudo_Selector& rhs) const;
-    virtual Compound_Selector* unify_with(Compound_Selector*, Context&);
+    virtual SimpleSequence_Selector* unify_with(SimpleSequence_Selector*, Context&);
     ATTACH_OPERATIONS()
   };
 
@@ -2169,11 +2223,6 @@ 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.
@@ -2185,6 +2234,20 @@ namespace Sass {
       }
       return hash_;
     }
+    virtual bool has_parent_ref() {
+      // if (has_reference()) return true;
+      if (!selector()) return false;
+      return selector()->has_parent_ref();
+    }
+    virtual bool has_real_parent_ref() {
+      // if (has_reference()) return true;
+      if (!selector()) return false;
+      return selector()->has_real_parent_ref();
+    }
+    virtual bool has_wrapped_selector()
+    {
+      return true;
+    }
     virtual unsigned long specificity()
     {
       return selector_ ? selector_->specificity() : 0;
@@ -2196,16 +2259,16 @@ namespace Sass {
     ATTACH_OPERATIONS()
   };
 
-  struct Complex_Selector_Pointer_Compare {
-    bool operator() (const Complex_Selector* const pLeft, const Complex_Selector* const pRight) const;
+  struct Sequence_Selector_Pointer_Compare {
+    bool operator() (const Sequence_Selector* const pLeft, const Sequence_Selector* const pRight) const;
   };
 
   ////////////////////////////////////////////////////////////////////////////
   // Simple selector sequences. Maintains flags indicating whether it contains
   // any parent references or placeholders, to simplify expansion.
   ////////////////////////////////////////////////////////////////////////////
-  typedef std::set<Complex_Selector*, Complex_Selector_Pointer_Compare> SourcesSet;
-  class Compound_Selector : public Selector, public Vectorized<Simple_Selector*> {
+  typedef std::set<Sequence_Selector*, Sequence_Selector_Pointer_Compare> SourcesSet;
+  class SimpleSequence_Selector : public Selector, public Vectorized<Simple_Selector*> {
   private:
     SourcesSet sources_;
     ADD_PROPERTY(bool, extended);
@@ -2214,10 +2277,10 @@ namespace Sass {
     void adjust_after_pushing(Simple_Selector* s)
     {
       // if (s->has_reference())   has_reference(true);
-      if (s->has_placeholder()) has_placeholder(true);
+      // if (s->has_placeholder()) has_placeholder(true);
     }
   public:
-    Compound_Selector(ParserState pstate, size_t s = 0)
+    SimpleSequence_Selector(ParserState pstate, size_t s = 0)
     : Selector(pstate),
       Vectorized<Simple_Selector*>(s),
       extended_(false),
@@ -2230,30 +2293,33 @@ namespace Sass {
       return false;
     };
 
+    SimpleSequence_Selector& operator<<(Simple_Selector* element);
+
     bool is_universal() const
     {
       return length() == 1 && (*this)[0]->is_universal();
     }
 
-    Complex_Selector* to_complex(Memory_Manager& mem);
-    Compound_Selector* unify_with(Compound_Selector* rhs, Context& ctx);
-    // virtual Selector_Placeholder* find_placeholder();
+    Sequence_Selector* to_complex(Memory_Manager& mem);
+    SimpleSequence_Selector* unify_with(SimpleSequence_Selector* rhs, Context& ctx);
+    // virtual Placeholder_Selector* find_placeholder();
     virtual bool has_parent_ref();
+    virtual bool has_real_parent_ref();
     Simple_Selector* base()
     {
       // Implement non-const in terms of const. Safe to const_cast since this method is non-const
-      return const_cast<Simple_Selector*>(static_cast<const Compound_Selector*>(this)->base());
+      return const_cast<Simple_Selector*>(static_cast<const SimpleSequence_Selector*>(this)->base());
     }
     const Simple_Selector* base() const {
       if (length() == 0) return 0;
       // ToDo: why is this needed?
-      if (dynamic_cast<Type_Selector*>((*this)[0]))
+      if (dynamic_cast<Element_Selector*>((*this)[0]))
         return (*this)[0];
       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 bool is_superselector_of(SimpleSequence_Selector* sub, std::string wrapped = "");
+    virtual bool is_superselector_of(Sequence_Selector* sub, std::string wrapped = "");
+    virtual bool is_superselector_of(CommaSequence_Selector* sub, std::string wrapped = "");
     virtual size_t hash()
     {
       if (Selector::hash_ == 0) {
@@ -2270,6 +2336,24 @@ namespace Sass {
       return sum;
     }
 
+    virtual bool has_wrapped_selector()
+    {
+      if (length() == 0) return false;
+      if (Simple_Selector* ss = elements().front()) {
+        if (ss->has_wrapped_selector()) return true;
+      }
+      return false;
+    }
+
+    virtual bool has_placeholder()
+    {
+      if (length() == 0) return false;
+      if (Simple_Selector* ss = elements().front()) {
+        if (ss->has_placeholder()) return true;
+      }
+      return false;
+    }
+
     bool is_empty_reference()
     {
       return length() == 1 &&
@@ -2277,18 +2361,18 @@ namespace Sass {
     }
     std::vector<std::string> to_str_vec(); // sometimes need to convert to a flat "by-value" data structure
 
-    bool operator<(const Compound_Selector& rhs) const;
+    bool operator<(const SimpleSequence_Selector& rhs) const;
 
-    bool operator==(const Compound_Selector& rhs) const;
-    inline bool operator!=(const Compound_Selector& rhs) const { return !(*this == rhs); }
+    bool operator==(const SimpleSequence_Selector& rhs) const;
+    inline bool operator!=(const SimpleSequence_Selector& rhs) const { return !(*this == rhs); }
 
     SourcesSet& sources() { return sources_; }
     void clearSources() { sources_.clear(); }
     void mergeSources(SourcesSet& sources, Context& ctx);
 
-    Compound_Selector* clone(Context&) const; // does not clone the Simple_Selector*s
+    SimpleSequence_Selector* clone(Context&) const; // does not clone the Simple_Selector*s
 
-    Compound_Selector* minus(Compound_Selector* rhs, Context& ctx);
+    SimpleSequence_Selector* minus(SimpleSequence_Selector* rhs, Context& ctx);
     ATTACH_OPERATIONS()
   };
 
@@ -2297,13 +2381,13 @@ namespace Sass {
   // CSS selector combinators (">", "+", "~", and whitespace). Essentially a
   // linked list.
   ////////////////////////////////////////////////////////////////////////////
-  class Complex_Selector : public Selector {
+  class Sequence_Selector : public Selector {
   public:
     enum Combinator { ANCESTOR_OF, PARENT_OF, PRECEDES, ADJACENT_TO, REFERENCE };
   private:
     ADD_PROPERTY(Combinator, combinator)
-    ADD_PROPERTY(Compound_Selector*, head)
-    ADD_PROPERTY(Complex_Selector*, tail)
+    ADD_PROPERTY(SimpleSequence_Selector*, head)
+    ADD_PROPERTY(Sequence_Selector*, tail)
     ADD_PROPERTY(String*, reference);
   public:
     bool contains_placeholder() {
@@ -2311,10 +2395,10 @@ namespace Sass {
       if (tail() && tail()->contains_placeholder()) return true;
       return false;
     };
-    Complex_Selector(ParserState pstate,
+    Sequence_Selector(ParserState pstate,
                      Combinator c = ANCESTOR_OF,
-                     Compound_Selector* h = 0,
-                     Complex_Selector* t = 0,
+                     SimpleSequence_Selector* h = 0,
+                     Sequence_Selector* t = 0,
                      String* r = 0)
     : Selector(pstate),
       combinator_(c),
@@ -2322,11 +2406,12 @@ namespace Sass {
       reference_(r)
     {
       // if ((h && h->has_reference())   || (t && t->has_reference()))   has_reference(true);
-      if ((h && h->has_placeholder()) || (t && t->has_placeholder())) has_placeholder(true);
+      // if ((h && h->has_placeholder()) || (t && t->has_placeholder())) has_placeholder(true);
     }
     virtual bool has_parent_ref();
+    virtual bool has_real_parent_ref();
 
-    Complex_Selector* skip_empty_reference()
+    Sequence_Selector* skip_empty_reference()
     {
       if ((!head_ || !head_->length() || head_->is_empty_reference()) &&
           combinator() == Combinator::ANCESTOR_OF)
@@ -2346,36 +2431,36 @@ namespace Sass {
              combinator() == Combinator::ANCESTOR_OF;
     }
 
-    Complex_Selector* context(Context&);
+    Sequence_Selector* context(Context&);
 
 
     // front returns the first real tail
     // skips over parent and empty ones
-    const Complex_Selector* first() const;
+    const Sequence_Selector* first() const;
 
     // last returns the last real tail
-    const Complex_Selector* last() const;
+    const Sequence_Selector* last() const;
 
-    Selector_List* tails(Context& ctx, Selector_List* tails);
+    CommaSequence_Selector* tails(Context& ctx, CommaSequence_Selector* tails);
 
     // unconstant accessors
-    Complex_Selector* first();
-    Complex_Selector* last();
+    Sequence_Selector* first();
+    Sequence_Selector* last();
 
     // some shortcuts that should be removed
-    const Complex_Selector* innermost() const { return last(); };
-    Complex_Selector* innermost() { return last(); };
+    const Sequence_Selector* innermost() const { return last(); };
+    Sequence_Selector* innermost() { return last(); };
 
     size_t length() const;
-    Selector_List* parentize(Selector_List* parents, Context& ctx);
-    virtual bool is_superselector_of(Compound_Selector* sub, std::string wrapping = "");
-    virtual bool is_superselector_of(Complex_Selector* sub, std::string wrapping = "");
-    virtual bool is_superselector_of(Selector_List* sub, std::string wrapping = "");
-    // virtual Selector_Placeholder* find_placeholder();
-    Selector_List* unify_with(Complex_Selector* rhs, Context& ctx);
+    CommaSequence_Selector* resolve_parent_refs(Context& ctx, CommaSequence_Selector* parents, bool implicit_parent = true);
+    virtual bool is_superselector_of(SimpleSequence_Selector* sub, std::string wrapping = "");
+    virtual bool is_superselector_of(Sequence_Selector* sub, std::string wrapping = "");
+    virtual bool is_superselector_of(CommaSequence_Selector* sub, std::string wrapping = "");
+    // virtual Placeholder_Selector* find_placeholder();
+    CommaSequence_Selector* unify_with(Sequence_Selector* rhs, Context& ctx);
     Combinator clear_innermost();
-    void append(Context&, Complex_Selector*);
-    void set_innermost(Complex_Selector*, Combinator);
+    void append(Context&, Sequence_Selector*);
+    void set_innermost(Sequence_Selector*, Combinator);
     virtual size_t hash()
     {
       if (hash_ == 0) {
@@ -2398,9 +2483,19 @@ namespace Sass {
       if (tail_) tail_->set_media_block(mb);
       if (head_) head_->set_media_block(mb);
     }
-    bool operator<(const Complex_Selector& rhs) const;
-    bool operator==(const Complex_Selector& rhs) const;
-    inline bool operator!=(const Complex_Selector& rhs) const { return !(*this == rhs); }
+    virtual bool has_wrapped_selector() {
+      if (head_ && head_->has_wrapped_selector()) return true;
+      if (tail_ && tail_->has_wrapped_selector()) return true;
+      return false;
+    }
+    virtual bool has_placeholder() {
+      if (head_ && head_->has_placeholder()) return true;
+      if (tail_ && tail_->has_placeholder()) return true;
+      return false;
+    }
+    bool operator<(const Sequence_Selector& rhs) const;
+    bool operator==(const Sequence_Selector& rhs) const;
+    inline bool operator!=(const Sequence_Selector& rhs) const { return !(*this == rhs); }
     SourcesSet sources()
     {
       //s = Set.new
@@ -2409,8 +2504,8 @@ namespace Sass {
 
       SourcesSet srcs;
 
-      Compound_Selector* pHead = head();
-      Complex_Selector*  pTail = tail();
+      SimpleSequence_Selector* pHead = head();
+      Sequence_Selector*  pTail = tail();
 
       if (pHead) {
         SourcesSet& headSources = pHead->sources();
@@ -2426,9 +2521,9 @@ namespace Sass {
     }
     void addSources(SourcesSet& sources, Context& ctx) {
       // members.map! {|m| m.is_a?(SimpleSequence) ? m.with_more_sources(sources) : m}
-      Complex_Selector* pIter = this;
+      Sequence_Selector* pIter = this;
       while (pIter) {
-        Compound_Selector* pHead = pIter->head();
+        SimpleSequence_Selector* pHead = pIter->head();
 
         if (pHead) {
           pHead->mergeSources(sources, ctx);
@@ -2438,9 +2533,9 @@ namespace Sass {
       }
     }
     void clearSources() {
-      Complex_Selector* pIter = this;
+      Sequence_Selector* pIter = this;
       while (pIter) {
-        Compound_Selector* pHead = pIter->head();
+        SimpleSequence_Selector* pHead = pIter->head();
 
         if (pHead) {
           pHead->clearSources();
@@ -2449,38 +2544,39 @@ namespace Sass {
         pIter = pIter->tail();
       }
     }
-    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();
+    Sequence_Selector* clone(Context&) const;      // does not clone SimpleSequence_Selector*s
+    Sequence_Selector* cloneFully(Context&) const; // clones SimpleSequence_Selector*s
+    // std::vector<SimpleSequence_Selector*> to_vector();
     ATTACH_OPERATIONS()
   };
 
-  typedef std::deque<Complex_Selector*> ComplexSelectorDeque;
-  typedef Subset_Map<std::string, std::pair<Complex_Selector*, Compound_Selector*> > ExtensionSubsetMap;
+  typedef std::deque<Sequence_Selector*> ComplexSelectorDeque;
+  typedef Subset_Map<std::string, std::pair<Sequence_Selector*, SimpleSequence_Selector*> > ExtensionSubsetMap;
 
   ///////////////////////////////////
   // Comma-separated selector groups.
   ///////////////////////////////////
-  class Selector_List : public Selector, public Vectorized<Complex_Selector*> {
+  class CommaSequence_Selector : public Selector, public Vectorized<Sequence_Selector*> {
     ADD_PROPERTY(std::vector<std::string>, wspace)
   protected:
-    void adjust_after_pushing(Complex_Selector* c);
+    void adjust_after_pushing(Sequence_Selector* c);
   public:
-    Selector_List(ParserState pstate, size_t s = 0)
-    : Selector(pstate), Vectorized<Complex_Selector*>(s), wspace_(0)
+    CommaSequence_Selector(ParserState pstate, size_t s = 0)
+    : Selector(pstate), Vectorized<Sequence_Selector*>(s), wspace_(0)
     { }
     std::string type() { return "list"; }
     // remove parent selector references
     // basically unwraps parsed selectors
     virtual bool has_parent_ref();
+    virtual bool has_real_parent_ref();
     void remove_parent_selectors();
-    // virtual Selector_Placeholder* find_placeholder();
-    Selector_List* parentize(Selector_List* parents, Context& ctx);
-    virtual bool is_superselector_of(Compound_Selector* sub, std::string wrapping = "");
-    virtual bool is_superselector_of(Complex_Selector* sub, std::string wrapping = "");
-    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 Placeholder_Selector* find_placeholder();
+    CommaSequence_Selector* resolve_parent_refs(Context& ctx, CommaSequence_Selector* parents, bool implicit_parent = true);
+    virtual bool is_superselector_of(SimpleSequence_Selector* sub, std::string wrapping = "");
+    virtual bool is_superselector_of(Sequence_Selector* sub, std::string wrapping = "");
+    virtual bool is_superselector_of(CommaSequence_Selector* sub, std::string wrapping = "");
+    CommaSequence_Selector* unify_with(CommaSequence_Selector*, Context&);
+    void populate_extends(CommaSequence_Selector*, Context&, ExtensionSubsetMap&);
     virtual size_t hash()
     {
       if (Selector::hash_ == 0) {
@@ -2502,14 +2598,26 @@ namespace Sass {
     }
     virtual void set_media_block(Media_Block* mb) {
       media_block(mb);
-      for (Complex_Selector* cs : elements()) {
+      for (Sequence_Selector* cs : elements()) {
         cs->set_media_block(mb);
       }
     }
-    Selector_List* clone(Context&) const;      // does not clone Compound_Selector*s
-    Selector_List* cloneFully(Context&) const; // clones Compound_Selector*s
+    virtual bool has_wrapped_selector() {
+      for (Sequence_Selector* cs : elements()) {
+        if (cs->has_wrapped_selector()) return true;
+      }
+      return false;
+    }
+    virtual bool has_placeholder() {
+      for (Sequence_Selector* cs : elements()) {
+        if (cs->has_placeholder()) return true;
+      }
+      return false;
+    }
+    CommaSequence_Selector* clone(Context&) const;      // does not clone SimpleSequence_Selector*s
+    CommaSequence_Selector* cloneFully(Context&) const; // clones SimpleSequence_Selector*s
     virtual bool operator==(const Selector& rhs) const;
-    virtual bool operator==(const Selector_List& rhs) const;
+    virtual bool operator==(const CommaSequence_Selector& rhs) const;
     // Selector Lists can be compared to comma lists
     virtual bool operator==(const Expression& rhs) const;
     ATTACH_OPERATIONS()
@@ -2522,10 +2630,10 @@ namespace Sass {
     // is required for proper stl collection ordering) is implemented using string comparision. This gives stable sorting
     // behavior, and can be used to determine if the selectors would have exactly idential output. operator== matches the
     // ruby sass implementations for eql, which sometimes perform order independent comparisions (like set comparisons of the
-    // members of a SimpleSequence (Compound_Selector)).
+    // members of a SimpleSequence (SimpleSequence_Selector)).
     //
     // Due to the reliance on operator== and operater< behavior, this templated method is currently only intended for
-    // use with Compound_Selector and Complex_Selector objects.
+    // use with SimpleSequence_Selector and Sequence_Selector objects.
     if (simpleSelectorOrderDependent) {
       return !(one < two) && !(two < one);
     } else {
@@ -2534,8 +2642,8 @@ namespace Sass {
   }
 
   // compare function for sorting and probably other other uses
-  struct cmp_complex_selector { inline bool operator() (const Complex_Selector* l, const Complex_Selector* r) { return (*l < *r); } };
-  struct cmp_compound_selector { inline bool operator() (const Compound_Selector* l, const Compound_Selector* r) { return (*l < *r); } };
+  struct cmp_complex_selector { inline bool operator() (const Sequence_Selector* l, const Sequence_Selector* r) { return (*l < *r); } };
+  struct cmp_compound_selector { inline bool operator() (const SimpleSequence_Selector* l, const SimpleSequence_Selector* r) { return (*l < *r); } };
   struct cmp_simple_selector { inline bool operator() (const Simple_Selector* l, const Simple_Selector* r) { return (*l < *r); } };
 
 }