sassc 1.10.1 → 1.11.0

data/ext/libsass/src/eval.hpp

@@ -3,6 +3,7 @@
 
 #include "ast.hpp"
 #include "context.hpp"
+#include "listize.hpp"
 #include "operation.hpp"
 #include "environment.hpp"
 
@@ -22,11 +23,12 @@ namespace Sass {
     Eval(Expand& exp);
     ~Eval();
 
+    bool force;
     bool is_in_comment;
 
     Env* environment();
     Context& context();
-    Selector_List* selector();
+    CommaSequence_Selector* selector();
     Backtrace* backtrace();
 
     // for evaluating function bodies
@@ -50,11 +52,12 @@ namespace Sass {
     Expression* operator()(Variable*);
     Expression* operator()(Textual*);
     Expression* operator()(Number*);
+    Expression* operator()(Color*);
     Expression* operator()(Boolean*);
     Expression* operator()(String_Schema*);
     Expression* operator()(String_Quoted*);
     Expression* operator()(String_Constant*);
-    // Expression* operator()(Selector_List*);
+    // Expression* operator()(CommaSequence_Selector*);
     Expression* operator()(Media_Query*);
     Expression* operator()(Media_Query_Expression*);
     Expression* operator()(At_Root_Query*);
@@ -68,17 +71,18 @@ namespace Sass {
     Expression* operator()(Comment*);
 
     // these will return selectors
-    Selector_List* operator()(Selector_List*);
-    Selector_List* operator()(Complex_Selector*);
+    CommaSequence_Selector* operator()(CommaSequence_Selector*);
+    CommaSequence_Selector* operator()(Sequence_Selector*);
     Attribute_Selector* operator()(Attribute_Selector*);
     // they don't have any specific implementatio (yet)
-    Type_Selector* operator()(Type_Selector* s) { return s; };
+    Element_Selector* operator()(Element_Selector* s) { return s; };
     Pseudo_Selector* operator()(Pseudo_Selector* s) { return s; };
     Wrapped_Selector* operator()(Wrapped_Selector* s) { return s; };
-    Selector_Qualifier* operator()(Selector_Qualifier* s) { return s; };
-    Selector_Placeholder* operator()(Selector_Placeholder* s) { return s; };
+    Class_Selector* operator()(Class_Selector* s) { return s; };
+    Id_Selector* operator()(Id_Selector* s) { return s; };
+    Placeholder_Selector* operator()(Placeholder_Selector* s) { return s; };
     // actual evaluated selectors
-    Selector_List* operator()(Selector_Schema*);
+    CommaSequence_Selector* operator()(Selector_Schema*);
     Expression* operator()(Parent_Selector*);
 
     template <typename U>

data/ext/libsass/src/expand.cpp

@@ -11,17 +11,23 @@
 
 namespace Sass {
 
-  Expand::Expand(Context& ctx, Env* env, Backtrace* bt)
+  // simple endless recursion protection
+  const unsigned int maxRecursion = 500;
+  static unsigned int recursions = 0;
+
+  Expand::Expand(Context& ctx, Env* env, Backtrace* bt, std::vector<CommaSequence_Selector*>* stack)
   : ctx(ctx),
     eval(Eval(*this)),
     env_stack(std::vector<Env*>()),
     block_stack(std::vector<Block*>()),
     call_stack(std::vector<AST_Node*>()),
     property_stack(std::vector<String*>()),
-    selector_stack(std::vector<Selector_List*>()),
+    selector_stack(std::vector<CommaSequence_Selector*>()),
     media_block_stack(std::vector<Media_Block*>()),
     backtrace_stack(std::vector<Backtrace*>()),
-    in_keyframes(false)
+    in_keyframes(false),
+    at_root_without_rule(false),
+    old_at_root_without_rule(false)
   {
     env_stack.push_back(0);
     env_stack.push_back(env);
@@ -29,7 +35,8 @@ namespace Sass {
     call_stack.push_back(0);
     // import_stack.push_back(0);
     property_stack.push_back(0);
-    selector_stack.push_back(0);
+    if (stack == NULL) { selector_stack.push_back(0); }
+    else { selector_stack.insert(selector_stack.end(), stack->begin(), stack->end()); }
     media_block_stack.push_back(0);
     backtrace_stack.push_back(0);
     backtrace_stack.push_back(bt);
@@ -47,7 +54,7 @@ namespace Sass {
     return 0;
   }
 
-  Selector_List* Expand::selector()
+  CommaSequence_Selector* Expand::selector()
   {
     if (selector_stack.size() > 0)
       return selector_stack.back();
@@ -86,23 +93,26 @@ namespace Sass {
 
   Statement* Expand::operator()(Ruleset* r)
   {
-    // reset when leaving scope
+    LOCAL_FLAG(old_at_root_without_rule, at_root_without_rule);
 
     if (in_keyframes) {
       Keyframe_Rule* k = SASS_MEMORY_NEW(ctx.mem, Keyframe_Rule, r->pstate(), r->block()->perform(this)->block());
       if (r->selector()) {
         selector_stack.push_back(0);
-        k->selector(static_cast<Selector_List*>(r->selector()->perform(&eval)));
+        k->selector(static_cast<CommaSequence_Selector*>(r->selector()->perform(&eval)));
         selector_stack.pop_back();
       }
       return k;
     }
 
+    // reset when leaving scope
+    LOCAL_FLAG(at_root_without_rule, false);
+
     // do some special checks for the base level rules
     if (r->is_root()) {
-      if (Selector_List* selector_list = dynamic_cast<Selector_List*>(r->selector())) {
-        for (Complex_Selector* complex_selector : selector_list->elements()) {
-          Complex_Selector* tail = complex_selector;
+      if (CommaSequence_Selector* selector_list = dynamic_cast<CommaSequence_Selector*>(r->selector())) {
+        for (Sequence_Selector* complex_selector : selector_list->elements()) {
+          Sequence_Selector* tail = complex_selector;
           while (tail) {
             if (tail->head()) for (Simple_Selector* header : tail->head()->elements()) {
               if (dynamic_cast<Parent_Selector*>(header) == NULL) continue; // skip all others
@@ -116,13 +126,13 @@ namespace Sass {
     }
 
     Expression* ex = r->selector()->perform(&eval);
-    Selector_List* sel = dynamic_cast<Selector_List*>(ex);
+    CommaSequence_Selector* sel = dynamic_cast<CommaSequence_Selector*>(ex);
     if (sel == 0) throw std::runtime_error("Expanded null selector");
 
     if (sel->length() == 0 || sel->has_parent_ref()) {
       bool has_parent_selector = false;
       for (size_t i = 0, L = selector_stack.size(); i < L && !has_parent_selector; i++) {
-        Selector_List* ll = selector_stack.at(i);
+        CommaSequence_Selector* ll = selector_stack.at(i);
         has_parent_selector = ll != 0 && ll->length() > 0;
       }
       if (!has_parent_selector) {
@@ -131,10 +141,9 @@ namespace Sass {
     }
 
     selector_stack.push_back(sel);
-    Env* env = 0;
+    Env env(environment());
     if (block_stack.back()->is_root()) {
-      env = new Env(environment());
-      env_stack.push_back(env);
+      env_stack.push_back(&env);
     }
     sel->set_media_block(media_block_stack.back());
     Block* blk = r->block()->perform(this)->block();
@@ -145,48 +154,14 @@ namespace Sass {
     selector_stack.pop_back();
     if (block_stack.back()->is_root()) {
       env_stack.pop_back();
-      delete env;
     }
+
     rr->is_root(r->is_root());
     rr->tabs(r->tabs());
 
     return rr;
   }
 
-  Statement* Expand::operator()(Propset* p)
-  {
-    property_stack.push_back(p->property_fragment());
-    Block* expanded_block = p->block()->perform(this)->block();
-
-    for (size_t i = 0, L = expanded_block->length(); i < L; ++i) {
-      Statement* stm = (*expanded_block)[i];
-      if (Declaration* dec = static_cast<Declaration*>(stm)) {
-        String_Schema* combined_prop = SASS_MEMORY_NEW(ctx.mem, String_Schema, p->pstate());
-        if (!property_stack.empty()) {
-          *combined_prop << property_stack.back()->perform(&eval)
-                         << SASS_MEMORY_NEW(ctx.mem, String_Quoted,
-             p->pstate(), "-")
-             << dec->property(); // TODO: eval the prop into a string constant
-        }
-        else {
-          *combined_prop << dec->property();
-        }
-        dec->property(combined_prop);
-        *block_stack.back() << dec;
-      }
-      else if (typeid(*stm) == typeid(Comment)) {
-        // drop comments in propsets
-      }
-      else {
-        error("contents of namespaced properties must result in style declarations only", stm->pstate(), backtrace());
-      }
-    }
-
-    property_stack.pop_back();
-
-    return 0;
-  }
-
   Statement* Expand::operator()(Supports_Block* f)
   {
     Expression* condition = f->condition()->perform(&eval);
@@ -219,16 +194,19 @@ namespace Sass {
   Statement* Expand::operator()(At_Root_Block* a)
   {
     Block* ab = a->block();
-    // if (ab) ab->is_root(true);
     Expression* ae = a->expression();
+
     if (ae) ae = ae->perform(&eval);
     else ae = SASS_MEMORY_NEW(ctx.mem, At_Root_Query, a->pstate());
+
+    LOCAL_FLAG(at_root_without_rule, true);
+    LOCAL_FLAG(in_keyframes, false);
+
     Block* bb = ab ? ab->perform(this)->block() : 0;
     At_Root_Block* aa = SASS_MEMORY_NEW(ctx.mem, At_Root_Block,
                                         a->pstate(),
                                         bb,
                                         static_cast<At_Root_Query*>(ae));
-    // aa->block()->is_root(true);
     return aa;
   }
 
@@ -254,15 +232,20 @@ namespace Sass {
 
   Statement* Expand::operator()(Declaration* d)
   {
+    Block* ab = d->block();
     String* old_p = d->property();
     String* new_p = static_cast<String*>(old_p->perform(&eval));
     Expression* value = d->value()->perform(&eval);
-    if (!value || (value->is_invisible() && !d->is_important())) return 0;
+    Block* bb = ab ? ab->perform(this)->block() : 0;
+    if (!bb) {
+      if (!value || (value->is_invisible() && !d->is_important())) return 0;
+    }
     Declaration* decl = SASS_MEMORY_NEW(ctx.mem, Declaration,
                                         d->pstate(),
                                         new_p,
                                         value,
-                                        d->is_important());
+                                        d->is_important(),
+                                        bb);
     decl->tabs(d->tabs());
     return decl;
   }
@@ -477,7 +460,7 @@ namespace Sass {
     if (expr->concrete_type() == Expression::MAP) {
       map = static_cast<Map*>(expr);
     }
-    else if (Selector_List* ls = dynamic_cast<Selector_List*>(expr)) {
+    else if (CommaSequence_Selector* ls = dynamic_cast<CommaSequence_Selector*>(expr)) {
       Listize listize(ctx.mem);
       list = dynamic_cast<List*>(ls->perform(&listize));
     }
@@ -513,7 +496,7 @@ namespace Sass {
     }
     else {
       // bool arglist = list->is_arglist();
-      if (list->length() == 1 && dynamic_cast<Selector_List*>(list)) {
+      if (list->length() == 1 && dynamic_cast<CommaSequence_Selector*>(list)) {
         list = dynamic_cast<Vectorized<Expression*>*>(list);
       }
       for (size_t i = 0, L = list->length(); i < L; ++i) {
@@ -573,11 +556,11 @@ namespace Sass {
   }
 
 
-  void Expand::expand_selector_list(Selector* s, Selector_List* extender) {
+  void Expand::expand_selector_list(Selector* s, CommaSequence_Selector* extender) {
 
-    if (Selector_List* sl = dynamic_cast<Selector_List*>(s)) {
-      for (Complex_Selector* complex_selector : sl->elements()) {
-        Complex_Selector* tail = complex_selector;
+    if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(s)) {
+      for (Sequence_Selector* complex_selector : sl->elements()) {
+        Sequence_Selector* tail = complex_selector;
         while (tail) {
           if (tail->head()) for (Simple_Selector* header : tail->head()->elements()) {
             if (dynamic_cast<Parent_Selector*>(header) == NULL) continue; // skip all others
@@ -590,24 +573,24 @@ namespace Sass {
     }
 
 
-    Selector_List* contextualized = dynamic_cast<Selector_List*>(s->perform(&eval));
+    CommaSequence_Selector* contextualized = dynamic_cast<CommaSequence_Selector*>(s->perform(&eval));
     if (contextualized == NULL) return;
     for (auto complex_sel : contextualized->elements()) {
-      Complex_Selector* c = complex_sel;
+      Sequence_Selector* c = complex_sel;
       if (!c->head() || c->tail()) {
         std::string sel_str(contextualized->to_string(ctx.c_options));
         error("Can't extend " + sel_str + ": can't extend nested selectors", c->pstate(), backtrace());
       }
-      Compound_Selector* placeholder = c->head();
+      SimpleSequence_Selector* placeholder = c->head();
       if (contextualized->is_optional()) placeholder->is_optional(true);
       for (size_t i = 0, L = extender->length(); i < L; ++i) {
-        Complex_Selector* sel = (*extender)[i];
+        Sequence_Selector* sel = (*extender)[i];
         if (!(sel->head() && sel->head()->length() > 0 &&
             dynamic_cast<Parent_Selector*>((*sel->head())[0])))
         {
-          Compound_Selector* hh = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, (*extender)[i]->pstate());
+          SimpleSequence_Selector* hh = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, (*extender)[i]->pstate());
           hh->media_block((*extender)[i]->media_block());
-          Complex_Selector* ssel = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, (*extender)[i]->pstate());
+          Sequence_Selector* ssel = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, (*extender)[i]->pstate());
           ssel->media_block((*extender)[i]->media_block());
           if (sel->has_line_feed()) ssel->has_line_feed(true);
           Parent_Selector* ps = SASS_MEMORY_NEW(ctx.mem, Parent_Selector, (*extender)[i]->pstate());
@@ -626,13 +609,13 @@ namespace Sass {
 
   Statement* Expand::operator()(Extension* e)
   {
-    if (Selector_List* extender = dynamic_cast<Selector_List*>(selector())) {
+    if (CommaSequence_Selector* extender = dynamic_cast<CommaSequence_Selector*>(selector())) {
       Selector* s = e->selector();
       if (Selector_Schema* schema = dynamic_cast<Selector_Schema*>(s)) {
         if (schema->has_parent_ref()) s = eval(schema);
       }
-      if (Selector_List* sl = dynamic_cast<Selector_List*>(s)) {
-        for (Complex_Selector* cs : *sl) {
+      if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(s)) {
+        for (Sequence_Selector* cs : *sl) {
           if (cs != NULL && cs->head() != NULL) {
             cs->head()->media_block(media_block_stack.back());
           }
@@ -673,6 +656,12 @@ namespace Sass {
 
   Statement* Expand::operator()(Mixin_Call* c)
   {
+    recursions ++;
+
+    if (recursions > maxRecursion) {
+      throw Exception::StackError(*c);
+    }
+
     Env* env = environment();
     std::string full_name(c->name() + "[m]");
     if (!env->has(full_name)) {
@@ -704,10 +693,23 @@ namespace Sass {
     }
 
     bind(std::string("Mixin"), c->name(), params, args, &ctx, &new_env, &eval);
-    append_block(body);
-    backtrace_stack.pop_back();
+
+    Block* trace_block = SASS_MEMORY_NEW(ctx.mem, Block, c->pstate());
+    Trace* trace = SASS_MEMORY_NEW(ctx.mem, Trace, c->pstate(), c->name(), trace_block);
+
+
+    block_stack.push_back(trace_block);
+    for (auto bb : *body) {
+      Statement* ith = bb->perform(this);
+      if (ith) *trace->block() << ith;
+    }
+    block_stack.pop_back();
+
     env_stack.pop_back();
-    return 0;
+    backtrace_stack.pop_back();
+
+    recursions --;
+    return trace;
   }
 
   Statement* Expand::operator()(Content* c)
@@ -715,18 +717,23 @@ namespace Sass {
     Env* env = environment();
     // convert @content directives into mixin calls to the underlying thunk
     if (!env->has("@content[m]")) return 0;
+
     if (block_stack.back()->is_root()) {
       selector_stack.push_back(0);
     }
+
     Mixin_Call* call = SASS_MEMORY_NEW(ctx.mem, Mixin_Call,
                                        c->pstate(),
                                        "@content",
                                        SASS_MEMORY_NEW(ctx.mem, Arguments, c->pstate()));
-    Statement* stm = call->perform(this);
+
+    Trace* trace = dynamic_cast<Trace*>(call->perform(this));
+
     if (block_stack.back()->is_root()) {
       selector_stack.pop_back();
     }
-    return stm;
+
+    return trace;
   }
 
   // produce an error if something is not implemented

data/ext/libsass/src/expand.hpp

@@ -21,34 +21,35 @@ namespace Sass {
 
     Env* environment();
     Context& context();
-    Selector_List* selector();
+    CommaSequence_Selector* selector();
     Backtrace* backtrace();
 
     Context&          ctx;
     Eval              eval;
 
     // it's easier to work with vectors
-    std::vector<Env*>      env_stack;
-    std::vector<Block*>    block_stack;
-    std::vector<AST_Node*> call_stack;
-    std::vector<String*>   property_stack;
-    std::vector<Selector_List*> selector_stack;
-    std::vector<Media_Block*> media_block_stack;
-    std::vector<Backtrace*>backtrace_stack;
-    bool              in_keyframes;
+    std::vector<Env*>           env_stack;
+    std::vector<Block*>         block_stack;
+    std::vector<AST_Node*>      call_stack;
+    std::vector<String*>        property_stack;
+    std::vector<CommaSequence_Selector*> selector_stack;
+    std::vector<Media_Block*>   media_block_stack;
+    std::vector<Backtrace*>     backtrace_stack;
+    bool                        in_keyframes;
+    bool                        at_root_without_rule;
+    bool                        old_at_root_without_rule;
 
     Statement* fallback_impl(AST_Node* n);
 
   private:
-    void expand_selector_list(Selector*, Selector_List* extender);
+    void expand_selector_list(Selector*, CommaSequence_Selector* extender);
 
   public:
-    Expand(Context&, Env*, Backtrace*);
+    Expand(Context&, Env*, Backtrace*, std::vector<CommaSequence_Selector*>* stack = NULL);
     ~Expand() { }
 
     Statement* operator()(Block*);
     Statement* operator()(Ruleset*);
-    Statement* operator()(Propset*);
     Statement* operator()(Media_Block*);
     Statement* operator()(Supports_Block*);
     Statement* operator()(At_Root_Block*);

data/ext/libsass/src/extend.cpp

@@ -62,26 +62,26 @@
 namespace Sass {
 
 
-  typedef std::pair<Complex_Selector*, Compound_Selector*> ExtensionPair;
+  typedef std::pair<Sequence_Selector*, SimpleSequence_Selector*> ExtensionPair;
   typedef std::vector<ExtensionPair> SubsetMapEntries;
 
 #ifdef DEBUG
 
   // TODO: move the ast specific ostream operators into ast.hpp/ast.cpp
-  std::ostream& operator<<(std::ostream& os, const Complex_Selector::Combinator combinator) {
+  std::ostream& operator<<(std::ostream& os, const Sequence_Selector::Combinator combinator) {
     switch (combinator) {
-      case Complex_Selector::ANCESTOR_OF: os << "\" \""; break;
-      case Complex_Selector::PARENT_OF:   os << "\">\""; break;
-      case Complex_Selector::PRECEDES:    os << "\"~\""; break;
-      case Complex_Selector::ADJACENT_TO: os << "\"+\""; break;
-      case Complex_Selector::REFERENCE: os    << "\"/\""; break;
+      case Sequence_Selector::ANCESTOR_OF: os << "\" \""; break;
+      case Sequence_Selector::PARENT_OF:   os << "\">\""; break;
+      case Sequence_Selector::PRECEDES:    os << "\"~\""; break;
+      case Sequence_Selector::ADJACENT_TO: os << "\"+\""; break;
+      case Sequence_Selector::REFERENCE:   os << "\"/\""; break;
     }
 
     return os;
   }
 
 
-  std::ostream& operator<<(std::ostream& os, Compound_Selector& compoundSelector) {
+  std::ostream& operator<<(std::ostream& os, SimpleSequence_Selector& compoundSelector) {
     for (size_t i = 0, L = compoundSelector.length(); i < L; ++i) {
       if (i > 0) os << ", ";
       os << compoundSelector[i]->to_string();
@@ -94,7 +94,7 @@ namespace Sass {
     return os;
   }
 
-  // Print a string representation of a Compound_Selector
+  // Print a string representation of a SimpleSequence_Selector
   static void printSimpleSelector(Simple_Selector* pSimpleSelector, const char* message=NULL, bool newline=true) {
 
     if (message) {
@@ -112,13 +112,13 @@ namespace Sass {
     }
   }
 
-  // Print a string representation of a Compound_Selector
-    typedef std::pair<Compound_Selector*, Complex_Selector*> SelsNewSeqPair;
+  // Print a string representation of a SimpleSequence_Selector
+    typedef std::pair<SimpleSequence_Selector*, Sequence_Selector*> SelsNewSeqPair;
     typedef std::vector<SelsNewSeqPair> SelsNewSeqPairCollection;
 
 
-  // Print a string representation of a Compound_Selector
-  static void printCompoundSelector(Compound_Selector* pCompoundSelector, const char* message=NULL, bool newline=true) {
+  // Print a string representation of a SimpleSequence_Selector
+  static void printCompoundSelector(SimpleSequence_Selector* pCompoundSelector, const char* message=NULL, bool newline=true) {
 
     if (message) {
       std::cerr << message;
@@ -136,13 +136,13 @@ namespace Sass {
   }
 
 
-  std::ostream& operator<<(std::ostream& os, Complex_Selector& complexSelector) {
+  std::ostream& operator<<(std::ostream& os, Sequence_Selector& complexSelector) {
 
     os << "[";
-    Complex_Selector* pIter = &complexSelector;
+    Sequence_Selector* pIter = &complexSelector;
     bool first = true;
     while (pIter) {
-      if (pIter->combinator() != Complex_Selector::ANCESTOR_OF) {
+      if (pIter->combinator() != Sequence_Selector::ANCESTOR_OF) {
         if (!first) {
           os << ", ";
         }
@@ -169,8 +169,8 @@ namespace Sass {
   }
 
 
-  // Print a string representation of a Complex_Selector
-  static void printComplexSelector(Complex_Selector* pComplexSelector, const char* message=NULL, bool newline=true) {
+  // Print a string representation of a Sequence_Selector
+  static void printComplexSelector(Sequence_Selector* pComplexSelector, const char* message=NULL, bool newline=true) {
 
     if (message) {
       std::cerr << message;
@@ -201,8 +201,8 @@ namespace Sass {
         std::cerr << ", ";
       }
       std::cerr << "[";
-      Compound_Selector* pSels = pair.first;
-      Complex_Selector* pNewSelector = pair.second;
+      SimpleSequence_Selector* pSels = pair.first;
+      Sequence_Selector* pNewSelector = pair.second;
       std::cerr << "[" << *pSels << "], ";
       printComplexSelector(pNewSelector, NULL, false);
     }
@@ -225,7 +225,7 @@ namespace Sass {
     typedef std::deque<std::string> SourceStrings;
     SourceStrings sourceStrings;
     for (SourcesSet::iterator iterator = sources.begin(), iteratorEnd = sources.end(); iterator != iteratorEnd; ++iterator) {
-      Complex_Selector* pSource = *iterator;
+      Sequence_Selector* pSource = *iterator;
       std::stringstream sstream;
       sstream << complexSelectorToNode(pSource, ctx);
       sourceStrings.push_back(sstream.str());
@@ -254,8 +254,8 @@ namespace Sass {
     os << "SUBSET_MAP_ENTRIES[";
 
     for (SubsetMapEntries::iterator iterator = entries.begin(), endIterator = entries.end(); iterator != endIterator; ++iterator) {
-      Complex_Selector* pExtComplexSelector = iterator->first;    // The selector up to where the @extend is (ie, the thing to merge)
-      Compound_Selector* pExtCompoundSelector = iterator->second; // The stuff after the @extend
+      Sequence_Selector* pExtComplexSelector = iterator->first;    // The selector up to where the @extend is (ie, the thing to merge)
+      SimpleSequence_Selector* pExtCompoundSelector = iterator->second; // The stuff after the @extend
 
       if (iterator != entries.begin()) {
         os << ", ";
@@ -287,17 +287,17 @@ namespace Sass {
   }
 #endif
 
-  static bool parentSuperselector(Complex_Selector* pOne, Complex_Selector* pTwo, Context& ctx) {
-    // TODO: figure out a better way to create a Complex_Selector from scratch
+  static bool parentSuperselector(Sequence_Selector* pOne, Sequence_Selector* pTwo, Context& ctx) {
+    // TODO: figure out a better way to create a Sequence_Selector from scratch
     // TODO: There's got to be a better way. This got ugly quick...
     Position noPosition(-1, -1, -1);
-    Type_Selector fakeParent(ParserState("[FAKE]"), "temp");
-    Compound_Selector fakeHead(ParserState("[FAKE]"), 1 /*size*/);
+    Element_Selector fakeParent(ParserState("[FAKE]"), "temp");
+    SimpleSequence_Selector fakeHead(ParserState("[FAKE]"), 1 /*size*/);
     fakeHead.elements().push_back(&fakeParent);
-    Complex_Selector fakeParentContainer(ParserState("[FAKE]"), Complex_Selector::ANCESTOR_OF, &fakeHead /*head*/, NULL /*tail*/);
+    Sequence_Selector fakeParentContainer(ParserState("[FAKE]"), Sequence_Selector::ANCESTOR_OF, &fakeHead /*head*/, NULL /*tail*/);
 
-    pOne->set_innermost(&fakeParentContainer, Complex_Selector::ANCESTOR_OF);
-    pTwo->set_innermost(&fakeParentContainer, Complex_Selector::ANCESTOR_OF);
+    pOne->set_innermost(&fakeParentContainer, Sequence_Selector::ANCESTOR_OF);
+    pTwo->set_innermost(&fakeParentContainer, Sequence_Selector::ANCESTOR_OF);
 
     bool isSuperselector = pOne->is_superselector_of(pTwo);
 
@@ -318,7 +318,7 @@ namespace Sass {
     Node result = Node::createCollection();
 
     for (ComplexSelectorDeque::const_iterator iter = deque.begin(), iterEnd = deque.end(); iter != iterEnd; iter++) {
-      Complex_Selector* pChild = *iter;
+      Sequence_Selector* pChild = *iter;
       result.collection()->push_back(complexSelectorToNode(pChild, ctx));
     }
 
@@ -331,7 +331,7 @@ namespace Sass {
 
     Context& mCtx;
 
-    bool operator()(Complex_Selector* pOne, Complex_Selector* pTwo, Complex_Selector*& pOut) const {
+    bool operator()(Sequence_Selector* pOne, Sequence_Selector* pTwo, Sequence_Selector*& pOut) const {
       /*
       This code is based on the following block from ruby sass' subweave
         do |s1, s2|
@@ -347,7 +347,7 @@ namespace Sass {
         return true;
       }
 
-      if (pOne->combinator() != Complex_Selector::ANCESTOR_OF || pTwo->combinator() != Complex_Selector::ANCESTOR_OF) {
+      if (pOne->combinator() != Sequence_Selector::ANCESTOR_OF || pTwo->combinator() != Sequence_Selector::ANCESTOR_OF) {
         return false;
       }
 
@@ -382,7 +382,7 @@ namespace Sass {
     }
 
 
-    Complex_Selector* pCompareOut = NULL;
+    Sequence_Selector* pCompareOut = NULL;
     if (comparator(x[i], y[j], pCompareOut)) {
       DEBUG_PRINTLN(LCS, "RETURNING AFTER ELEM COMPARE")
       lcs_backtrace(c, x, y, i - 1, j - 1, comparator, out);
@@ -419,7 +419,7 @@ namespace Sass {
 
     for (size_t i = 1; i < x.size(); i++) {
       for (size_t j = 1; j < y.size(); j++) {
-        Complex_Selector* pCompareOut = NULL;
+        Sequence_Selector* pCompareOut = NULL;
 
         if (comparator(x[i], y[j], pCompareOut)) {
           c[i][j] = c[i - 1][j - 1] + 1;
@@ -559,7 +559,7 @@ namespace Sass {
       for (NodeDeque::iterator seqs1Iter = seqs1.collection()->begin(), seqs1EndIter = seqs1.collection()->end(); seqs1Iter != seqs1EndIter; ++seqs1Iter) {
         Node& seq1 = *seqs1Iter;
 
-        Complex_Selector* pSeq1 = nodeToComplexSelector(seq1, ctx);
+        Sequence_Selector* pSeq1 = nodeToComplexSelector(seq1, ctx);
 
         // Compute the maximum specificity. This requires looking at the "sources" of the sequence. See SimpleSequence.sources in the ruby code
         // for a good description of sources.
@@ -576,7 +576,7 @@ namespace Sass {
         DEBUG_EXEC(TRIM, printSourcesSet(sources, ctx, "TRIM SOURCES: "))
 
         for (SourcesSet::iterator sourcesSetIterator = sources.begin(), sourcesSetIteratorEnd = sources.end(); sourcesSetIterator != sourcesSetIteratorEnd; ++sourcesSetIterator) {
-          const Complex_Selector* const pCurrentSelector = *sourcesSetIterator;
+          const Sequence_Selector* const pCurrentSelector = *sourcesSetIterator;
           maxSpecificity = std::max(maxSpecificity, pCurrentSelector->specificity());
         }
 
@@ -606,7 +606,7 @@ namespace Sass {
           for (NodeDeque::iterator seqs2Iter = seqs2.collection()->begin(), seqs2IterEnd = seqs2.collection()->end(); seqs2Iter != seqs2IterEnd; ++seqs2Iter) {
             Node& seq2 = *seqs2Iter;
 
-            Complex_Selector* pSeq2 = nodeToComplexSelector(seq2, ctx);
+            Sequence_Selector* pSeq2 = nodeToComplexSelector(seq2, ctx);
 
             DEBUG_PRINTLN(TRIM, "SEQ2 SPEC: " << pSeq2->specificity())
             DEBUG_PRINTLN(TRIM, "IS SPEC: " << pSeq2->specificity() << " >= " << maxSpecificity << " " << (pSeq2->specificity() >= maxSpecificity ? "true" : "false"))
@@ -651,18 +651,18 @@ namespace Sass {
 
 
   static bool parentSuperselector(const Node& one, const Node& two, Context& ctx) {
-    // TODO: figure out a better way to create a Complex_Selector from scratch
+    // TODO: figure out a better way to create a Sequence_Selector from scratch
     // TODO: There's got to be a better way. This got ugly quick...
     Position noPosition(-1, -1, -1);
-    Type_Selector fakeParent(ParserState("[FAKE]"), "temp");
-    Compound_Selector fakeHead(ParserState("[FAKE]"), 1 /*size*/);
+    Element_Selector fakeParent(ParserState("[FAKE]"), "temp");
+    SimpleSequence_Selector fakeHead(ParserState("[FAKE]"), 1 /*size*/);
     fakeHead.elements().push_back(&fakeParent);
-    Complex_Selector fakeParentContainer(ParserState("[FAKE]"), Complex_Selector::ANCESTOR_OF, &fakeHead /*head*/, NULL /*tail*/);
+    Sequence_Selector fakeParentContainer(ParserState("[FAKE]"), Sequence_Selector::ANCESTOR_OF, &fakeHead /*head*/, NULL /*tail*/);
 
-    Complex_Selector* pOneWithFakeParent = nodeToComplexSelector(one, ctx);
-    pOneWithFakeParent->set_innermost(&fakeParentContainer, Complex_Selector::ANCESTOR_OF);
-    Complex_Selector* pTwoWithFakeParent = nodeToComplexSelector(two, ctx);
-    pTwoWithFakeParent->set_innermost(&fakeParentContainer, Complex_Selector::ANCESTOR_OF);
+    Sequence_Selector* pOneWithFakeParent = nodeToComplexSelector(one, ctx);
+    pOneWithFakeParent->set_innermost(&fakeParentContainer, Sequence_Selector::ANCESTOR_OF);
+    Sequence_Selector* pTwoWithFakeParent = nodeToComplexSelector(two, ctx);
+    pTwoWithFakeParent->set_innermost(&fakeParentContainer, Sequence_Selector::ANCESTOR_OF);
 
     return pOneWithFakeParent->is_superselector_of(pTwoWithFakeParent);
   }
@@ -970,7 +970,7 @@ namespace Sass {
       Node sel2 = seq2.collection()->back();
       seq2.collection()->pop_back();
 
-      if (op1.combinator() == Complex_Selector::PRECEDES && op2.combinator() == Complex_Selector::PRECEDES) {
+      if (op1.combinator() == Sequence_Selector::PRECEDES && op2.combinator() == Sequence_Selector::PRECEDES) {
 
         if (sel1.selector()->is_superselector_of(sel2.selector())) {
 
@@ -987,9 +987,9 @@ namespace Sass {
           DEBUG_PRINTLN(ALL, "sel1: " << sel1)
           DEBUG_PRINTLN(ALL, "sel2: " << sel2)
 
-          Complex_Selector* pMergedWrapper = sel1.selector()->clone(ctx); // Clone the Complex_Selector to get back to something we can transform to a node once we replace the head with the unification result
+          Sequence_Selector* pMergedWrapper = sel1.selector()->clone(ctx); // Clone the Sequence_Selector to get back to something we can transform to a node once we replace the head with the unification result
           // TODO: does subject matter? Ruby: return unless merged = sel1.unify(sel2.members, sel2.subject?)
-          Compound_Selector* pMerged = sel1.selector()->head()->unify_with(sel2.selector()->head(), ctx);
+          SimpleSequence_Selector* pMerged = sel1.selector()->head()->unify_with(sel2.selector()->head(), ctx);
           pMergedWrapper->head(pMerged);
 
           DEBUG_EXEC(ALL, printCompoundSelector(pMerged, "MERGED: "))
@@ -998,22 +998,22 @@ namespace Sass {
 
           Node firstPerm = Node::createCollection();
           firstPerm.collection()->push_back(sel1);
-          firstPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));
+          firstPerm.collection()->push_back(Node::createCombinator(Sequence_Selector::PRECEDES));
           firstPerm.collection()->push_back(sel2);
-          firstPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));
+          firstPerm.collection()->push_back(Node::createCombinator(Sequence_Selector::PRECEDES));
           newRes.collection()->push_back(firstPerm);
 
           Node secondPerm = Node::createCollection();
           secondPerm.collection()->push_back(sel2);
-          secondPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));
+          secondPerm.collection()->push_back(Node::createCombinator(Sequence_Selector::PRECEDES));
           secondPerm.collection()->push_back(sel1);
-          secondPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));
+          secondPerm.collection()->push_back(Node::createCombinator(Sequence_Selector::PRECEDES));
           newRes.collection()->push_back(secondPerm);
 
           if (pMerged) {
             Node mergedPerm = Node::createCollection();
             mergedPerm.collection()->push_back(Node::createSelector(pMergedWrapper, ctx));
-            mergedPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));
+            mergedPerm.collection()->push_back(Node::createCombinator(Sequence_Selector::PRECEDES));
             newRes.collection()->push_back(mergedPerm);
           }
 
@@ -1023,13 +1023,13 @@ namespace Sass {
 
         }
 
-      } else if (((op1.combinator() == Complex_Selector::PRECEDES && op2.combinator() == Complex_Selector::ADJACENT_TO)) || ((op1.combinator() == Complex_Selector::ADJACENT_TO && op2.combinator() == Complex_Selector::PRECEDES))) {
+      } else if (((op1.combinator() == Sequence_Selector::PRECEDES && op2.combinator() == Sequence_Selector::ADJACENT_TO)) || ((op1.combinator() == Sequence_Selector::ADJACENT_TO && op2.combinator() == Sequence_Selector::PRECEDES))) {
 
           Node tildeSel = sel1;
           Node tildeOp = op1;
           Node plusSel = sel2;
           Node plusOp = op2;
-          if (op1.combinator() != Complex_Selector::PRECEDES) {
+          if (op1.combinator() != Sequence_Selector::PRECEDES) {
             tildeSel = sel2;
             tildeOp = op2;
             plusSel = sel1;
@@ -1046,9 +1046,9 @@ namespace Sass {
             DEBUG_PRINTLN(ALL, "PLUS SEL: " << plusSel)
             DEBUG_PRINTLN(ALL, "TILDE SEL: " << tildeSel)
 
-            Complex_Selector* pMergedWrapper = plusSel.selector()->clone(ctx); // Clone the Complex_Selector to get back to something we can transform to a node once we replace the head with the unification result
+            Sequence_Selector* pMergedWrapper = plusSel.selector()->clone(ctx); // Clone the Sequence_Selector to get back to something we can transform to a node once we replace the head with the unification result
             // TODO: does subject matter? Ruby: merged = plus_sel.unify(tilde_sel.members, tilde_sel.subject?)
-            Compound_Selector* pMerged = plusSel.selector()->head()->unify_with(tildeSel.selector()->head(), ctx);
+            SimpleSequence_Selector* pMerged = plusSel.selector()->head()->unify_with(tildeSel.selector()->head(), ctx);
             pMergedWrapper->head(pMerged);
 
             DEBUG_EXEC(ALL, printCompoundSelector(pMerged, "MERGED: "))
@@ -1057,15 +1057,15 @@ namespace Sass {
 
             Node firstPerm = Node::createCollection();
             firstPerm.collection()->push_back(tildeSel);
-            firstPerm.collection()->push_back(Node::createCombinator(Complex_Selector::PRECEDES));
+            firstPerm.collection()->push_back(Node::createCombinator(Sequence_Selector::PRECEDES));
             firstPerm.collection()->push_back(plusSel);
-            firstPerm.collection()->push_back(Node::createCombinator(Complex_Selector::ADJACENT_TO));
+            firstPerm.collection()->push_back(Node::createCombinator(Sequence_Selector::ADJACENT_TO));
             newRes.collection()->push_back(firstPerm);
 
             if (pMerged) {
               Node mergedPerm = Node::createCollection();
               mergedPerm.collection()->push_back(Node::createSelector(pMergedWrapper, ctx));
-              mergedPerm.collection()->push_back(Node::createCombinator(Complex_Selector::ADJACENT_TO));
+              mergedPerm.collection()->push_back(Node::createCombinator(Sequence_Selector::ADJACENT_TO));
               newRes.collection()->push_back(mergedPerm);
             }
 
@@ -1074,7 +1074,7 @@ namespace Sass {
             DEBUG_PRINTLN(ALL, "RESULT: " << res)
 
           }
-      } else if (op1.combinator() == Complex_Selector::PARENT_OF && (op2.combinator() == Complex_Selector::PRECEDES || op2.combinator() == Complex_Selector::ADJACENT_TO)) {
+      } else if (op1.combinator() == Sequence_Selector::PARENT_OF && (op2.combinator() == Sequence_Selector::PRECEDES || op2.combinator() == Sequence_Selector::ADJACENT_TO)) {
 
         res.collection()->push_front(op2);
         res.collection()->push_front(sel2);
@@ -1082,7 +1082,7 @@ namespace Sass {
         seq1.collection()->push_back(sel1);
         seq1.collection()->push_back(op1);
 
-      } else if (op2.combinator() == Complex_Selector::PARENT_OF && (op1.combinator() == Complex_Selector::PRECEDES || op1.combinator() == Complex_Selector::ADJACENT_TO)) {
+      } else if (op2.combinator() == Sequence_Selector::PARENT_OF && (op1.combinator() == Sequence_Selector::PRECEDES || op1.combinator() == Sequence_Selector::ADJACENT_TO)) {
 
         res.collection()->push_front(op1);
         res.collection()->push_front(sel1);
@@ -1095,9 +1095,9 @@ namespace Sass {
         DEBUG_PRINTLN(ALL, "sel1: " << sel1)
         DEBUG_PRINTLN(ALL, "sel2: " << sel2)
 
-        Complex_Selector* pMergedWrapper = sel1.selector()->clone(ctx); // Clone the Complex_Selector to get back to something we can transform to a node once we replace the head with the unification result
+        Sequence_Selector* pMergedWrapper = sel1.selector()->clone(ctx); // Clone the Sequence_Selector to get back to something we can transform to a node once we replace the head with the unification result
         // TODO: does subject matter? Ruby: return unless merged = sel1.unify(sel2.members, sel2.subject?)
-        Compound_Selector* pMerged = sel1.selector()->head()->unify_with(sel2.selector()->head(), ctx);
+        SimpleSequence_Selector* pMerged = sel1.selector()->head()->unify_with(sel2.selector()->head(), ctx);
         pMergedWrapper->head(pMerged);
 
         DEBUG_EXEC(ALL, printCompoundSelector(pMerged, "MERGED: "))
@@ -1121,7 +1121,7 @@ namespace Sass {
 
       Node op1 = ops1.collection()->front();
 
-      if (op1.combinator() == Complex_Selector::PARENT_OF && !seq2.collection()->empty() && seq2.collection()->back().selector()->is_superselector_of(seq1.collection()->back().selector())) {
+      if (op1.combinator() == Sequence_Selector::PARENT_OF && !seq2.collection()->empty() && seq2.collection()->back().selector()->is_superselector_of(seq1.collection()->back().selector())) {
         seq2.collection()->pop_back();
       }
 
@@ -1136,7 +1136,7 @@ namespace Sass {
 
       Node op2 = ops2.collection()->front();
 
-      if (op2.combinator() == Complex_Selector::PARENT_OF && !seq1.collection()->empty() && seq1.collection()->back().selector()->is_superselector_of(seq2.collection()->back().selector())) {
+      if (op2.combinator() == Sequence_Selector::PARENT_OF && !seq1.collection()->empty() && seq1.collection()->back().selector()->is_superselector_of(seq2.collection()->back().selector())) {
         seq1.collection()->pop_back();
       }
 
@@ -1509,10 +1509,10 @@ namespace Sass {
   // This forward declaration is needed since extendComplexSelector calls extendCompoundSelector, which may recursively
   // call extendComplexSelector again.
   static Node extendComplexSelector(
-    Complex_Selector* pComplexSelector,
+    Sequence_Selector* pComplexSelector,
     Context& ctx,
     ExtensionSubsetMap& subset_map,
-    std::set<Compound_Selector> seen, bool isReplace, bool isOriginal);
+    std::set<SimpleSequence_Selector> seen, bool isReplace, bool isOriginal);
 
 
 
@@ -1532,15 +1532,15 @@ namespace Sass {
   class GroupByToAFunctor {
   public:
     KeyType operator()(ExtensionPair& extPair) const {
-      Complex_Selector* pSelector = extPair.first;
+      Sequence_Selector* pSelector = extPair.first;
       return *pSelector;
     }
   };
   static Node extendCompoundSelector(
-    Compound_Selector* pSelector,
+    SimpleSequence_Selector* pSelector,
     Context& ctx,
     ExtensionSubsetMap& subset_map,
-    std::set<Compound_Selector> seen, bool isReplace) {
+    std::set<SimpleSequence_Selector> seen, bool isReplace) {
 
     DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pSelector, "EXTEND COMPOUND: "))
     // TODO: Ruby has another loop here to skip certain members?
@@ -1550,13 +1550,13 @@ namespace Sass {
 
     SubsetMapEntries entries = subset_map.get_v(pSelector->to_str_vec());
 
-    typedef std::vector<std::pair<Complex_Selector, std::vector<ExtensionPair> > > GroupedByToAResult;
+    typedef std::vector<std::pair<Sequence_Selector, std::vector<ExtensionPair> > > GroupedByToAResult;
 
-    GroupByToAFunctor<Complex_Selector> extPairKeyFunctor;
+    GroupByToAFunctor<Sequence_Selector> extPairKeyFunctor;
     GroupedByToAResult arr;
     group_by_to_a(entries, extPairKeyFunctor, arr);
 
-    typedef std::pair<Compound_Selector*, Complex_Selector*> SelsNewSeqPair;
+    typedef std::pair<SimpleSequence_Selector*, Sequence_Selector*> SelsNewSeqPair;
     typedef std::vector<SelsNewSeqPair> SelsNewSeqPairCollection;
 
 
@@ -1564,18 +1564,18 @@ namespace Sass {
 
 
     for (GroupedByToAResult::iterator groupedIter = arr.begin(), groupedIterEnd = arr.end(); groupedIter != groupedIterEnd; groupedIter++) {
-      std::pair<Complex_Selector, std::vector<ExtensionPair> >& groupedPair = *groupedIter;
+      std::pair<Sequence_Selector, std::vector<ExtensionPair> >& groupedPair = *groupedIter;
 
-      Complex_Selector& seq = groupedPair.first;
+      Sequence_Selector& seq = groupedPair.first;
       std::vector<ExtensionPair>& group = groupedPair.second;
 
       DEBUG_EXEC(EXTEND_COMPOUND, printComplexSelector(&seq, "SEQ: "))
 
 
-      Compound_Selector* pSels = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, pSelector->pstate());
+      SimpleSequence_Selector* pSels = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, pSelector->pstate());
       for (std::vector<ExtensionPair>::iterator groupIter = group.begin(), groupIterEnd = group.end(); groupIter != groupIterEnd; groupIter++) {
         ExtensionPair& pair = *groupIter;
-        Compound_Selector* pCompound = pair.second;
+        SimpleSequence_Selector* pCompound = pair.second;
         for (size_t index = 0; index < pCompound->length(); index++) {
           Simple_Selector* pSimpleSelector = (*pCompound)[index];
           (*pSels) << pSimpleSelector;
@@ -1585,21 +1585,21 @@ namespace Sass {
 
       DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pSels, "SELS: "))
 
-      Complex_Selector* pExtComplexSelector = &seq;    // The selector up to where the @extend is (ie, the thing to merge)
-      Compound_Selector* pExtCompoundSelector = pSels; // All the simple selectors to be replaced from the current compound selector from all extensions
+      Sequence_Selector* pExtComplexSelector = &seq;    // The selector up to where the @extend is (ie, the thing to merge)
+      SimpleSequence_Selector* pExtCompoundSelector = pSels; // All the simple selectors to be replaced from the current compound selector from all extensions
 
-      // TODO: This can return a Compound_Selector with no elements. Should that just be returning NULL?
+      // TODO: This can return a SimpleSequence_Selector with no elements. Should that just be returning NULL?
       // RUBY: self_without_sel = Sass::Util.array_minus(members, sels)
-      Compound_Selector* pSelectorWithoutExtendSelectors = pSelector->minus(pExtCompoundSelector, ctx);
+      SimpleSequence_Selector* pSelectorWithoutExtendSelectors = pSelector->minus(pExtCompoundSelector, ctx);
 
       DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pSelector, "MEMBERS: "))
       DEBUG_EXEC(EXTEND_COMPOUND, printCompoundSelector(pSelectorWithoutExtendSelectors, "SELF_WO_SEL: "))
 
-      Compound_Selector* pInnermostCompoundSelector = pExtComplexSelector->last()->head();
-      Compound_Selector* pUnifiedSelector = NULL;
+      SimpleSequence_Selector* pInnermostCompoundSelector = pExtComplexSelector->last()->head();
+      SimpleSequence_Selector* pUnifiedSelector = NULL;
 
       if (!pInnermostCompoundSelector) {
-        pInnermostCompoundSelector = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, pSelector->pstate());
+        pInnermostCompoundSelector = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, pSelector->pstate());
       }
 
       pUnifiedSelector = pInnermostCompoundSelector->unify_with(pSelectorWithoutExtendSelectors, ctx);
@@ -1618,14 +1618,14 @@ namespace Sass {
       // next if group.map {|e, _| check_directives_match!(e, parent_directives)}.none?
 
       // TODO: This seems a little fishy to me. See if it causes any problems. From the ruby, we should be able to just
-      // get rid of the last Compound_Selector and replace it with this one. I think the reason this code is more
-      // complex is that Complex_Selector contains a combinator, but in ruby combinators have already been filtered
+      // get rid of the last SimpleSequence_Selector and replace it with this one. I think the reason this code is more
+      // complex is that Sequence_Selector contains a combinator, but in ruby combinators have already been filtered
       // out and aren't operated on.
-      Complex_Selector* pNewSelector = pExtComplexSelector->cloneFully(ctx); // ->first();
+      Sequence_Selector* pNewSelector = pExtComplexSelector->cloneFully(ctx); // ->first();
 
-      Complex_Selector* pNewInnerMost = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, pSelector->pstate(), Complex_Selector::ANCESTOR_OF, pUnifiedSelector, NULL);
+      Sequence_Selector* pNewInnerMost = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, pSelector->pstate(), Sequence_Selector::ANCESTOR_OF, pUnifiedSelector, NULL);
 
-      Complex_Selector::Combinator combinator = pNewSelector->clear_innermost();
+      Sequence_Selector::Combinator combinator = pNewSelector->clear_innermost();
       pNewSelector->set_innermost(pNewInnerMost, combinator);
 
 #ifdef DEBUG
@@ -1642,7 +1642,7 @@ namespace Sass {
 
 
       // if (pSelector && pSelector->has_line_feed()) pNewInnerMost->has_line_feed(true);
-      // Set the sources on our new Complex_Selector to the sources of this simple sequence plus the thing we're extending.
+      // Set the sources on our new Sequence_Selector to the sources of this simple sequence plus the thing we're extending.
       DEBUG_PRINTLN(EXTEND_COMPOUND, "SOURCES SETTING ON NEW SEQ: " << complexSelectorToNode(pNewSelector, ctx))
 
       DEBUG_EXEC(EXTEND_COMPOUND, SourcesSet oldSet = pNewSelector->sources(); printSourcesSet(oldSet, ctx, "SOURCES NEW SEQ BEGIN: "))
@@ -1669,8 +1669,8 @@ namespace Sass {
     for (SelsNewSeqPairCollection::iterator holderIter = holder.begin(), holderIterEnd = holder.end(); holderIter != holderIterEnd; holderIter++) {
       SelsNewSeqPair& pair = *holderIter;
 
-      Compound_Selector* pSels = pair.first;
-      Complex_Selector* pNewSelector = pair.second;
+      SimpleSequence_Selector* pSels = pair.first;
+      Sequence_Selector* pNewSelector = pair.second;
 
 
       // RUBY??: next [] if seen.include?(sels)
@@ -1679,7 +1679,7 @@ namespace Sass {
       }
 
 
-      std::set<Compound_Selector> recurseSeen(seen);
+      std::set<SimpleSequence_Selector> recurseSeen(seen);
       recurseSeen.insert(*pSels);
 
 
@@ -1709,33 +1709,19 @@ namespace Sass {
 
 
   static bool complexSelectorHasExtension(
-    Complex_Selector* pComplexSelector,
+    Sequence_Selector* pComplexSelector,
     Context& ctx,
-    ExtensionSubsetMap& subset_map) {
+    ExtensionSubsetMap& subset_map,
+    std::set<SimpleSequence_Selector>& seen) {
 
     bool hasExtension = false;
 
-    Complex_Selector* pIter = pComplexSelector;
+    Sequence_Selector* pIter = pComplexSelector;
 
     while (!hasExtension && pIter) {
-      Compound_Selector* pHead = pIter->head();
+      SimpleSequence_Selector* pHead = pIter->head();
 
       if (pHead) {
-        for (Simple_Selector* pSimple : *pHead) {
-          if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(pSimple)) {
-            if (Selector_List* sl = dynamic_cast<Selector_List*>(ws->selector())) {
-              for (Complex_Selector* cs : sl->elements()) {
-                while (cs) {
-                  if (complexSelectorHasExtension(cs, ctx, subset_map)) {
-                    hasExtension = true;
-                    break;
-                  }
-                  cs = cs->tail();
-                }
-              }
-            }
-          }
-        }
         SubsetMapEntries entries = subset_map.get_v(pHead->to_str_vec());
         for (ExtensionPair ext : entries) {
           // check if both selectors have the same media block parent
@@ -1783,10 +1769,10 @@ namespace Sass {
      next [[sseq_or_op]] unless sseq_or_op.is_a?(SimpleSequence)
    */
   static Node extendComplexSelector(
-    Complex_Selector* pComplexSelector,
+    Sequence_Selector* pComplexSelector,
     Context& ctx,
     ExtensionSubsetMap& subset_map,
-    std::set<Compound_Selector> seen, bool isReplace, bool isOriginal) {
+    std::set<SimpleSequence_Selector> seen, bool isReplace, bool isOriginal) {
 
     Node complexSelector = complexSelectorToNode(pComplexSelector, ctx);
     DEBUG_PRINTLN(EXTEND_COMPLEX, "EXTEND COMPLEX: " << complexSelector)
@@ -1806,7 +1792,7 @@ namespace Sass {
       // RUBY: next [[sseq_or_op]] unless sseq_or_op.is_a?(SimpleSequence)
       if (!sseqOrOp.isSelector()) {
         // Wrap our Combinator in two collections to match ruby. This is essentially making a collection Node
-        // with one collection child. The collection child represents a Complex_Selector that is only a combinator.
+        // with one collection child. The collection child represents a Sequence_Selector that is only a combinator.
         Node outer = Node::createCollection();
         Node inner = Node::createCollection();
         outer.collection()->push_back(inner);
@@ -1815,7 +1801,7 @@ namespace Sass {
         continue;
       }
 
-      Compound_Selector* pCompoundSelector = sseqOrOp.selector()->head();
+      SimpleSequence_Selector* pCompoundSelector = sseqOrOp.selector()->head();
 
       // RUBY: extended = sseq_or_op.do_extend(extends, parent_directives, replace, seen)
       Node extended = extendCompoundSelector(pCompoundSelector, ctx, subset_map, seen, isReplace);
@@ -1823,9 +1809,9 @@ namespace Sass {
       DEBUG_PRINTLN(EXTEND_COMPLEX, "EXTENDED: " << extended)
 
 
-      // Prepend the Compound_Selector based on the choices logic; choices seems to be extend but with an ruby Array instead of a Sequence
+      // Prepend the SimpleSequence_Selector based on the choices logic; choices seems to be extend but with an ruby Array instead of a Sequence
       // due to the member mapping: choices = extended.map {|seq| seq.members}
-      Complex_Selector* pJustCurrentCompoundSelector = sseqOrOp.selector();
+      Sequence_Selector* pJustCurrentCompoundSelector = sseqOrOp.selector();
 
       // RUBY: extended.first.add_sources!([self]) if original && !has_placeholder?
       if (isOriginal && !pComplexSelector->has_placeholder()) {
@@ -1839,7 +1825,7 @@ namespace Sass {
       for (NodeDeque::iterator iterator = extended.collection()->begin(), endIterator = extended.collection()->end();
            iterator != endIterator; ++iterator) {
         Node& childNode = *iterator;
-        Complex_Selector* pExtensionSelector = nodeToComplexSelector(childNode, ctx);
+        Sequence_Selector* pExtensionSelector = nodeToComplexSelector(childNode, ctx);
         if (pExtensionSelector->is_superselector_of(pJustCurrentCompoundSelector)) {
           isSuperselector = true;
           break;
@@ -1906,33 +1892,40 @@ namespace Sass {
   /*
    This is the equivalent of ruby's CommaSequence.do_extend.
   */
-  Selector_List* Extend::extendSelectorList(Selector_List* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething) {
+  CommaSequence_Selector* Extend::extendSelectorList(CommaSequence_Selector* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething) {
+    std::set<SimpleSequence_Selector> seen;
+    return extendSelectorList(pSelectorList, ctx, subset_map, isReplace, extendedSomething, seen);
+  }
+
+  /*
+   This is the equivalent of ruby's CommaSequence.do_extend.
+  */
+  CommaSequence_Selector* Extend::extendSelectorList(CommaSequence_Selector* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething, std::set<SimpleSequence_Selector>& seen) {
 
-    Selector_List* pNewSelectors = SASS_MEMORY_NEW(ctx.mem, Selector_List, pSelectorList->pstate(), pSelectorList->length());
+    CommaSequence_Selector* pNewSelectors = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, pSelectorList->pstate(), pSelectorList->length());
 
     extendedSomething = false;
 
     for (size_t index = 0, length = pSelectorList->length(); index < length; index++) {
-      Complex_Selector* pSelector = (*pSelectorList)[index];
+      Sequence_Selector* pSelector = (*pSelectorList)[index];
 
       // ruby sass seems to keep a list of things that have extensions and then only extend those. We don't currently do that.
       // Since it's not that expensive to check if an extension exists in the subset map and since it can be relatively expensive to
       // run through the extend code (which does a data model transformation), check if there is anything to extend before doing
       // the extend. We might be able to optimize extendComplexSelector, but this approach keeps us closer to ruby sass (which helps
       // when debugging).
-      if (!complexSelectorHasExtension(pSelector, ctx, subset_map)) {
+      if (!complexSelectorHasExtension(pSelector, ctx, subset_map, seen)) {
         *pNewSelectors << pSelector;
         continue;
       }
 
       extendedSomething = true;
 
-      std::set<Compound_Selector> seen;
-
       Node extendedSelectors = extendComplexSelector(pSelector, ctx, subset_map, seen, isReplace, true);
       if (!pSelector->has_placeholder()) {
         if (!extendedSelectors.contains(complexSelectorToNode(pSelector, ctx), true /*simpleSelectorOrderDependent*/)) {
           *pNewSelectors << pSelector;
+          continue;
         }
       }
 
@@ -1951,32 +1944,46 @@ namespace Sass {
     pNewSelectors = remove_placeholders.remove_placeholders(pNewSelectors);
 
     // unwrap all wrapped selectors with inner lists
-    for (Complex_Selector* cur : *pNewSelectors) {
+    for (Sequence_Selector* cur : *pNewSelectors) {
       // process tails
       while (cur) {
         // process header
-        if (cur->head()) {
+        if (cur->head() && seen.find(*cur->head()) == seen.end()) {
+          std::set<SimpleSequence_Selector> recseen(seen);
+          recseen.insert(*cur->head());
           // create a copy since we add multiple items if stuff get unwrapped
-          Compound_Selector* cpy_head = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, cur->pstate());
+          SimpleSequence_Selector* cpy_head = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, cur->pstate());
           for (Simple_Selector* hs : *cur->head()) {
             if (Wrapped_Selector* ws = dynamic_cast<Wrapped_Selector*>(hs)) {
-              if (Selector_List* sl = dynamic_cast<Selector_List*>(ws->selector())) {
+              if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(ws->selector())) {
                 // special case for ruby ass
                 if (sl->empty()) {
                   // this seems inconsistent but it is how ruby sass seems to remove parentheses
-                  *cpy_head << SASS_MEMORY_NEW(ctx.mem, Type_Selector, hs->pstate(), ws->name());
+                  *cpy_head << SASS_MEMORY_NEW(ctx.mem, Element_Selector, hs->pstate(), ws->name());
                 }
                 // has wrapped selectors
                 else {
                   // extend the inner list of wrapped selector
-                  Selector_List* ext_sl = extendSelectorList(sl, ctx, subset_map);
+                  CommaSequence_Selector* ext_sl = extendSelectorList(sl, ctx, subset_map, recseen);
                   for (size_t i = 0; i < ext_sl->length(); i += 1) {
-                    if (Complex_Selector* ext_cs = ext_sl->at(i)) {
+                    if (Sequence_Selector* ext_cs = ext_sl->at(i)) {
                       // create clones for wrapped selector and the inner list
                       Wrapped_Selector* cpy_ws = SASS_MEMORY_NEW(ctx.mem, Wrapped_Selector, *ws);
-                      Selector_List* cpy_ws_sl = SASS_MEMORY_NEW(ctx.mem, Selector_List, sl->pstate());
+                      CommaSequence_Selector* cpy_ws_sl = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, sl->pstate());
                       // remove parent selectors from inner selector
-                      if (ext_cs->first()) *cpy_ws_sl << ext_cs->first();
+                      if (ext_cs->first() && ext_cs->first()->head()->length() > 0) {
+                        Wrapped_Selector* ext_ws = dynamic_cast<Wrapped_Selector*>(ext_cs->first()->head()->first());
+                        if (ext_ws/* && ext_cs->length() == 1*/) {
+                          CommaSequence_Selector* ws_cs = dynamic_cast<CommaSequence_Selector*>(ext_ws->selector());
+                          SimpleSequence_Selector* ws_ss = ws_cs->first()->head();
+                          if (!(
+                            dynamic_cast<Pseudo_Selector*>(ws_ss->first()) ||
+                            dynamic_cast<Element_Selector*>(ws_ss->first()) ||
+                            dynamic_cast<Placeholder_Selector*>(ws_ss->first())
+                          )) continue;
+                        }
+                        *cpy_ws_sl << ext_cs->first();
+                      }
                       // assign list to clone
                       cpy_ws->selector(cpy_ws_sl);
                       // append the clone
@@ -2038,7 +2045,7 @@ namespace Sass {
   template <typename ObjectType>
   static void extendObjectWithSelectorAndBlock(ObjectType* pObject, Context& ctx, ExtensionSubsetMap& subset_map) {
 
-    DEBUG_PRINTLN(EXTEND_OBJECT, "FOUND SELECTOR: " << static_cast<Selector_List*>(pObject->selector())->to_string(ctx.c_options))
+    DEBUG_PRINTLN(EXTEND_OBJECT, "FOUND SELECTOR: " << static_cast<CommaSequence_Selector*>(pObject->selector())->to_string(ctx.c_options))
 
     // Ruby sass seems to filter nodes that don't have any content well before we get here. I'm not sure the repercussions
     // of doing so, so for now, let's just not extend things that won't be output later.
@@ -2048,10 +2055,10 @@ namespace Sass {
     }
 
     bool extendedSomething = false;
-    Selector_List* pNewSelectorList = Extend::extendSelectorList(static_cast<Selector_List*>(pObject->selector()), ctx, subset_map, false, extendedSomething);
+    CommaSequence_Selector* pNewSelectorList = Extend::extendSelectorList(static_cast<CommaSequence_Selector*>(pObject->selector()), ctx, subset_map, false, extendedSomething);
 
     if (extendedSomething && pNewSelectorList) {
-      DEBUG_PRINTLN(EXTEND_OBJECT, "EXTEND ORIGINAL SELECTORS: " << static_cast<Selector_List*>(pObject->selector())->to_string(ctx.c_options))
+      DEBUG_PRINTLN(EXTEND_OBJECT, "EXTEND ORIGINAL SELECTORS: " << static_cast<CommaSequence_Selector*>(pObject->selector())->to_string(ctx.c_options))
       DEBUG_PRINTLN(EXTEND_OBJECT, "EXTEND SETTING NEW SELECTORS: " << pNewSelectorList->to_string(ctx.c_options))
       pNewSelectorList->remove_parent_selectors();
       pObject->selector(pNewSelectorList);
@@ -2076,8 +2083,8 @@ namespace Sass {
     if (b->is_root()) {
       // debug_subset_map(subset_map);
       for(auto const &it : subset_map.values()) {
-        Complex_Selector* sel = it.first ? it.first->first() : NULL;
-        Compound_Selector* ext = it.second ? it.second : NULL;
+        Sequence_Selector* sel = it.first ? it.first->first() : NULL;
+        SimpleSequence_Selector* ext = it.second ? it.second : NULL;
         if (ext && (ext->extended() || ext->is_optional())) continue;
         std::string str_sel(sel->to_string({ NESTED, 5 }));
         std::string str_ext(ext->to_string({ NESTED, 5 }));
@@ -2110,7 +2117,7 @@ namespace Sass {
 
   void Extend::operator()(Directive* a)
   {
-    // Selector_List* ls = dynamic_cast<Selector_List*>(a->selector());
+    // CommaSequence_Selector* ls = dynamic_cast<CommaSequence_Selector*>(a->selector());
     // selector_stack.push_back(ls);
     if (a->block()) a->block()->perform(this);
     // exp.selector_stack.pop_back();