sassc 1.10.1 → 1.11.0

data/ext/libsass/src/functions.hpp

@@ -7,7 +7,7 @@
 #include "sass/functions.h"
 
 #define BUILT_IN(name) Expression*\
-name(Env& env, Env& d_env, Context& ctx, Signature sig, ParserState pstate, Backtrace* backtrace)
+name(Env& env, Env& d_env, Context& ctx, Signature sig, ParserState pstate, Backtrace* backtrace, std::vector<CommaSequence_Selector*> selector_stack)
 
 namespace Sass {
   class Context;
@@ -17,7 +17,7 @@ namespace Sass {
   class Definition;
   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*>);
 
   Definition* make_native_function(Signature, Native_Function, Context& ctx);
   Definition* make_c_function(Sass_Function_Entry c_func, Context& ctx);

data/ext/libsass/src/inspect.cpp

@@ -51,13 +51,6 @@ namespace Sass {
     if (rule->block()) rule->block()->perform(this);
   }
 
-  void Inspect::operator()(Propset* propset)
-  {
-    propset->property_fragment()->perform(this);
-    append_colon_separator();
-    propset->block()->perform(this);
-  }
-
   void Inspect::operator()(Bubble* bubble)
   {
     append_indentation();
@@ -166,10 +159,6 @@ namespace Sass {
       append_token("@import", import);
       append_mandatory_space();
 
-      if (String_Quoted* strq = dynamic_cast<String_Quoted*>(import->urls().front())) {
-        strq->is_delayed(false);
-      }
-
       import->urls().front()->perform(this);
       if (import->urls().size() == 1) {
         if (import->media_queries()) {
@@ -183,10 +172,6 @@ namespace Sass {
         append_token("@import", import);
         append_mandatory_space();
 
-        if (String_Quoted* strq = dynamic_cast<String_Quoted*>(import->urls()[i])) {
-          strq->is_delayed(false);
-        }
-
         import->urls()[i]->perform(this);
         if (import->urls().size() - 1 == i) {
           if (import->media_queries()) {
@@ -390,7 +375,7 @@ namespace Sass {
         !list->from_selector() &&
         !dynamic_cast<List*>((*list)[0]) &&
         !dynamic_cast<List*>((*list)[0]) &&
-        !dynamic_cast<Selector_List*>((*list)[0])) {
+        !dynamic_cast<CommaSequence_Selector*>((*list)[0])) {
       append_string("(");
     }
     else if (!in_declaration && (list->separator() == SASS_HASH ||
@@ -432,7 +417,7 @@ namespace Sass {
         !list->from_selector() &&
         !dynamic_cast<List*>((*list)[0]) &&
         !dynamic_cast<List*>((*list)[0]) &&
-        !dynamic_cast<Selector_List*>((*list)[0])) {
+        !dynamic_cast<CommaSequence_Selector*>((*list)[0])) {
       append_string(",)");
     }
     else if (!in_declaration && (list->separator() == SASS_HASH ||
@@ -451,10 +436,8 @@ namespace Sass {
          (output_style() == INSPECT) || (
           expr->op().ws_before
           && (!expr->is_interpolant())
-          && (!expr->is_delayed() ||
-          expr->is_left_interpolant() ||
-          expr->is_right_interpolant()
-          )
+          && (expr->is_left_interpolant() ||
+              expr->is_right_interpolant())
 
     )) append_string(" ");
     switch (expr->type()) {
@@ -477,10 +460,8 @@ namespace Sass {
          (output_style() == INSPECT) || (
           expr->op().ws_after
           && (!expr->is_interpolant())
-          && (!expr->is_delayed()
-              || expr->is_left_interpolant()
-              || expr->is_right_interpolant()
-          )
+          && (expr->is_left_interpolant() ||
+              expr->is_right_interpolant())
     )) append_string(" ");
     expr->right()->perform(this);
   }
@@ -895,10 +876,10 @@ namespace Sass {
 
   void Inspect::operator()(Parent_Selector* p)
   {
-    append_string("&");
+    if (p->is_real_parent_ref()) append_string("&");
   }
 
-  void Inspect::operator()(Selector_Placeholder* s)
+  void Inspect::operator()(Placeholder_Selector* s)
   {
     append_token(s->name(), s);
     if (s->has_line_break()) append_optional_linefeed();
@@ -906,12 +887,19 @@ namespace Sass {
 
   }
 
-  void Inspect::operator()(Type_Selector* s)
+  void Inspect::operator()(Element_Selector* s)
   {
     append_token(s->ns_name(), s);
   }
 
-  void Inspect::operator()(Selector_Qualifier* s)
+  void Inspect::operator()(Class_Selector* s)
+  {
+    append_token(s->ns_name(), s);
+    if (s->has_line_break()) append_optional_linefeed();
+    if (s->has_line_break()) append_indentation();
+  }
+
+  void Inspect::operator()(Id_Selector* s)
   {
     append_token(s->ns_name(), s);
     if (s->has_line_break()) append_optional_linefeed();
@@ -957,7 +945,7 @@ namespace Sass {
     in_wrapped = was;
   }
 
-  void Inspect::operator()(Compound_Selector* s)
+  void Inspect::operator()(SimpleSequence_Selector* s)
   {
     for (size_t i = 0, L = s->length(); i < L; ++i) {
       (*s)[i]->perform(this);
@@ -969,13 +957,13 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Complex_Selector* c)
+  void Inspect::operator()(Sequence_Selector* c)
   {
-    Compound_Selector*           head = c->head();
-    Complex_Selector*            tail = c->tail();
-    Complex_Selector::Combinator comb = c->combinator();
+    SimpleSequence_Selector*      head = c->head();
+    Sequence_Selector*            tail = c->tail();
+    Sequence_Selector::Combinator comb = c->combinator();
 
-    if (comb == Complex_Selector::ANCESTOR_OF && (!head || head->empty())) {
+    if (comb == Sequence_Selector::ANCESTOR_OF && (!head || head->empty())) {
       if (tail) tail->perform(this);
       return;
     }
@@ -990,30 +978,30 @@ namespace Sass {
     if (head && head->length() != 0) head->perform(this);
     bool is_empty = !head || head->length() == 0 || head->is_empty_reference();
     bool is_tail = head && !head->is_empty_reference() && tail;
-    if (output_style() == COMPRESSED && comb != Complex_Selector::ANCESTOR_OF) scheduled_space = 0;
+    if (output_style() == COMPRESSED && comb != Sequence_Selector::ANCESTOR_OF) scheduled_space = 0;
 
     switch (comb) {
-      case Complex_Selector::ANCESTOR_OF:
+      case Sequence_Selector::ANCESTOR_OF:
         if (is_tail) append_mandatory_space();
       break;
-      case Complex_Selector::PARENT_OF:
+      case Sequence_Selector::PARENT_OF:
         append_optional_space();
         append_string(">");
         append_optional_space();
       break;
-      case Complex_Selector::ADJACENT_TO:
+      case Sequence_Selector::ADJACENT_TO:
         append_optional_space();
         append_string("+");
         append_optional_space();
       break;
-      case Complex_Selector::REFERENCE:
+      case Sequence_Selector::REFERENCE:
         append_mandatory_space();
         append_string("/");
         c->reference()->perform(this);
         append_string("/");
         append_mandatory_space();
       break;
-      case Complex_Selector::PRECEDES:
+      case Sequence_Selector::PRECEDES:
         if (is_empty) append_optional_space();
         else append_mandatory_space();
         append_string("~");
@@ -1021,7 +1009,7 @@ namespace Sass {
         else append_optional_space();
       break;
     }
-    if (tail && comb != Complex_Selector::ANCESTOR_OF) {
+    if (tail && comb != Sequence_Selector::ANCESTOR_OF) {
       if (c->has_line_break()) append_optional_linefeed();
     }
     if (tail) tail->perform(this);
@@ -1032,7 +1020,7 @@ namespace Sass {
     }
   }
 
-  void Inspect::operator()(Selector_List* g)
+  void Inspect::operator()(CommaSequence_Selector* g)
   {
 
     if (g->empty()) {
@@ -1047,7 +1035,7 @@ namespace Sass {
     // probably ruby sass eqivalent of element_needs_parens
     if (output_style() == TO_SASS && g->length() == 1 &&
       (!dynamic_cast<List*>((*g)[0]) &&
-       !dynamic_cast<Selector_List*>((*g)[0]))) {
+       !dynamic_cast<CommaSequence_Selector*>((*g)[0]))) {
       append_string("(");
     }
     else if (!in_declaration && in_comma_array) {
@@ -1073,7 +1061,7 @@ namespace Sass {
     // probably ruby sass eqivalent of element_needs_parens
     if (output_style() == TO_SASS && g->length() == 1 &&
       (!dynamic_cast<List*>((*g)[0]) &&
-       !dynamic_cast<Selector_List*>((*g)[0]))) {
+       !dynamic_cast<CommaSequence_Selector*>((*g)[0]))) {
       append_string(",)");
     }
     else if (!in_declaration && in_comma_array) {

data/ext/libsass/src/inspect.hpp

@@ -23,7 +23,6 @@ namespace Sass {
     // statements
     virtual void operator()(Block*);
     virtual void operator()(Ruleset*);
-    virtual void operator()(Propset*);
     virtual void operator()(Bubble*);
     virtual void operator()(Supports_Block*);
     virtual void operator()(Media_Block*);
@@ -82,15 +81,16 @@ namespace Sass {
     virtual void operator()(Arguments*);
     // selectors
     virtual void operator()(Selector_Schema*);
-    virtual void operator()(Selector_Placeholder*);
-    virtual void operator()(Type_Selector*);
-    virtual void operator()(Selector_Qualifier*);
+    virtual void operator()(Placeholder_Selector*);
+    virtual void operator()(Element_Selector*);
+    virtual void operator()(Class_Selector*);
+    virtual void operator()(Id_Selector*);
     virtual void operator()(Attribute_Selector*);
     virtual void operator()(Pseudo_Selector*);
     virtual void operator()(Wrapped_Selector*);
-    virtual void operator()(Compound_Selector*);
-    virtual void operator()(Complex_Selector*);
-    virtual void operator()(Selector_List*);
+    virtual void operator()(SimpleSequence_Selector*);
+    virtual void operator()(Sequence_Selector*);
+    virtual void operator()(CommaSequence_Selector*);
 
     // template <typename U>
     // void fallback(U x) { fallback_impl(reinterpret_cast<AST_Node*>(x)); }

data/ext/libsass/src/json.cpp

@@ -399,7 +399,13 @@ char *json_encode_string(const char *str)
   SB sb;
   sb_init(&sb);
 
-  emit_string(&sb, str);
+  try {
+    emit_string(&sb, str);
+  }
+  catch (std::exception) {
+    sb_free(&sb);
+    throw;
+  }
 
   return sb_finish(&sb);
 }
@@ -409,10 +415,16 @@ char *json_stringify(const JsonNode *node, const char *space)
   SB sb;
   sb_init(&sb);
 
-  if (space != NULL)
-    emit_value_indented(&sb, node, space, 0);
-  else
-    emit_value(&sb, node);
+  try {
+    if (space != NULL)
+      emit_value_indented(&sb, node, space, 0);
+    else
+      emit_value(&sb, node);
+  }
+  catch (std::exception) {
+    sb_free(&sb);
+    throw;
+  }
 
   return sb_finish(&sb);
 }

data/ext/libsass/src/lexer.cpp

@@ -81,9 +81,9 @@ namespace Sass {
     bool is_nonascii(const char& chr)
     {
       return (
-        (unsigned(chr) > 127 && unsigned(chr) < 55296) ||
-        (unsigned(chr) > 57343 && unsigned(chr) < 65534) ||
-        (unsigned(chr) > 65535 && unsigned(chr) < 1114111)
+        (unsigned(chr) >= 128 && unsigned(chr) <= 15572911) ||
+        (unsigned(chr) >= 15630464 && unsigned(chr) <= 15712189) ||
+        (unsigned(chr) >= 4036001920)
       );
     }
 

data/ext/libsass/src/listize.cpp

@@ -14,7 +14,7 @@ namespace Sass {
   : mem(mem)
   {  }
 
-  Expression* Listize::operator()(Selector_List* sel)
+  Expression* Listize::operator()(CommaSequence_Selector* sel)
   {
     List* l = SASS_MEMORY_NEW(mem, List, sel->pstate(), sel->length(), SASS_COMMA);
     l->from_selector(true);
@@ -26,7 +26,7 @@ namespace Sass {
     return SASS_MEMORY_NEW(mem, Null, l->pstate());
   }
 
-  Expression* Listize::operator()(Compound_Selector* sel)
+  Expression* Listize::operator()(SimpleSequence_Selector* sel)
   {
     std::string str;
     for (size_t i = 0, L = sel->length(); i < L; ++i) {
@@ -36,11 +36,11 @@ namespace Sass {
     return SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), str);
   }
 
-  Expression* Listize::operator()(Complex_Selector* sel)
+  Expression* Listize::operator()(Sequence_Selector* sel)
   {
     List* l = SASS_MEMORY_NEW(mem, List, sel->pstate(), 2);
     l->from_selector(true);
-    Compound_Selector* head = sel->head();
+    SimpleSequence_Selector* head = sel->head();
     if (head && !head->is_empty_reference())
     {
       Expression* hh = head->perform(this);
@@ -51,23 +51,23 @@ namespace Sass {
       : sel->reference()->to_string();
     switch(sel->combinator())
     {
-      case Complex_Selector::PARENT_OF:
+      case Sequence_Selector::PARENT_OF:
         *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), ">");
       break;
-      case Complex_Selector::ADJACENT_TO:
+      case Sequence_Selector::ADJACENT_TO:
         *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "+");
       break;
-      case Complex_Selector::REFERENCE:
+      case Sequence_Selector::REFERENCE:
         *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "/" + reference + "/");
       break;
-      case Complex_Selector::PRECEDES:
+      case Sequence_Selector::PRECEDES:
         *l << SASS_MEMORY_NEW(mem, String_Quoted, sel->pstate(), "~");
       break;
-      case Complex_Selector::ANCESTOR_OF:
+      case Sequence_Selector::ANCESTOR_OF:
       break;
     }
 
-    Complex_Selector* tail = sel->tail();
+    Sequence_Selector* tail = sel->tail();
     if (tail)
     {
       Expression* tt = tail->perform(this);

data/ext/libsass/src/listize.hpp

@@ -24,9 +24,9 @@ namespace Sass {
     Listize(Memory_Manager&);
     ~Listize() { }
 
-    Expression* operator()(Selector_List*);
-    Expression* operator()(Complex_Selector*);
-    Expression* operator()(Compound_Selector*);
+    Expression* operator()(CommaSequence_Selector*);
+    Expression* operator()(Sequence_Selector*);
+    Expression* operator()(SimpleSequence_Selector*);
 
     template <typename U>
     Expression* fallback(U x) { return fallback_impl(x); }

data/ext/libsass/src/node.cpp

@@ -8,20 +8,20 @@
 namespace Sass {
 
 
-  Node Node::createCombinator(const Complex_Selector::Combinator& combinator) {
+  Node Node::createCombinator(const Sequence_Selector::Combinator& combinator) {
     NodeDequePtr null;
     return Node(COMBINATOR, combinator, NULL /*pSelector*/, null /*pCollection*/);
   }
 
 
-  Node Node::createSelector(Complex_Selector* pSelector, Context& ctx) {
+  Node Node::createSelector(Sequence_Selector* pSelector, Context& ctx) {
     NodeDequePtr null;
 
-    Complex_Selector* pStripped = pSelector->clone(ctx);
+    Sequence_Selector* pStripped = pSelector->clone(ctx);
     pStripped->tail(NULL);
-    pStripped->combinator(Complex_Selector::ANCESTOR_OF);
+    pStripped->combinator(Sequence_Selector::ANCESTOR_OF);
 
-    Node n(SELECTOR, Complex_Selector::ANCESTOR_OF, pStripped, null /*pCollection*/);
+    Node n(SELECTOR, Sequence_Selector::ANCESTOR_OF, pStripped, null /*pCollection*/);
     if (pSelector) n.got_line_feed = pSelector->has_line_feed();
     return n;
   }
@@ -29,23 +29,23 @@ namespace Sass {
 
   Node Node::createCollection() {
     NodeDequePtr pEmptyCollection = std::make_shared<NodeDeque>();
-    return Node(COLLECTION, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pEmptyCollection);
+    return Node(COLLECTION, Sequence_Selector::ANCESTOR_OF, NULL /*pSelector*/, pEmptyCollection);
   }
 
 
   Node Node::createCollection(const NodeDeque& values) {
     NodeDequePtr pShallowCopiedCollection = std::make_shared<NodeDeque>(values);
-    return Node(COLLECTION, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, pShallowCopiedCollection);
+    return Node(COLLECTION, Sequence_Selector::ANCESTOR_OF, NULL /*pSelector*/, pShallowCopiedCollection);
   }
 
 
   Node Node::createNil() {
     NodeDequePtr null;
-    return Node(NIL, Complex_Selector::ANCESTOR_OF, NULL /*pSelector*/, null /*pCollection*/);
+    return Node(NIL, Sequence_Selector::ANCESTOR_OF, NULL /*pSelector*/, null /*pCollection*/);
   }
 
 
-  Node::Node(const TYPE& type, Complex_Selector::Combinator combinator, Complex_Selector* pSelector, NodeDequePtr& pCollection)
+  Node::Node(const TYPE& type, Sequence_Selector::Combinator combinator, Sequence_Selector* pSelector, NodeDequePtr& pCollection)
   : got_line_feed(false), mType(type), mCombinator(combinator), mpSelector(pSelector), mpCollection(pCollection)
   { if (pSelector) got_line_feed = pSelector->has_line_feed(); }
 
@@ -140,11 +140,11 @@ namespace Sass {
     if (node.isCombinator()) {
 
       switch (node.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;
       }
 
     } else if (node.isNil()) {
@@ -177,7 +177,7 @@ namespace Sass {
 #endif
 
 
-  Node complexSelectorToNode(Complex_Selector* pToConvert, Context& ctx) {
+  Node complexSelectorToNode(Sequence_Selector* pToConvert, Context& ctx) {
     if (pToConvert == NULL) {
       return Node::createNil();
     }
@@ -187,7 +187,7 @@ namespace Sass {
 
     // unwrap the selector from parent ref
     if (pToConvert->head() && pToConvert->head()->has_parent_ref()) {
-      Complex_Selector* tail = pToConvert->tail();
+      Sequence_Selector* tail = pToConvert->tail();
       if (tail) tail->has_line_feed(pToConvert->has_line_feed());
       pToConvert = tail;
     }
@@ -199,14 +199,14 @@ namespace Sass {
       if (pToConvert->head() == NULL || empty_parent_ref) {
       }
 
-      // the first Complex_Selector may contain a dummy head pointer, skip it.
+      // the first Sequence_Selector may contain a dummy head pointer, skip it.
       if (pToConvert->head() != NULL && !empty_parent_ref) {
         node.collection()->push_back(Node::createSelector(pToConvert, ctx));
         if (has_lf) node.collection()->back().got_line_feed = has_lf;
         has_lf = false;
       }
 
-      if (pToConvert->combinator() != Complex_Selector::ANCESTOR_OF) {
+      if (pToConvert->combinator() != Sequence_Selector::ANCESTOR_OF) {
         node.collection()->push_back(Node::createCombinator(pToConvert->combinator()));
         if (has_lf) node.collection()->back().got_line_feed = has_lf;
         has_lf = false;
@@ -223,14 +223,14 @@ namespace Sass {
   }
 
 
-  Complex_Selector* nodeToComplexSelector(const Node& toConvert, Context& ctx) {
+  Sequence_Selector* nodeToComplexSelector(const Node& toConvert, Context& ctx) {
     if (toConvert.isNil()) {
       return NULL;
     }
 
 
     if (!toConvert.isCollection()) {
-      throw "The node to convert to a Complex_Selector* must be a collection type or nil.";
+      throw "The node to convert to a Sequence_Selector* must be a collection type or nil.";
     }
 
 
@@ -238,9 +238,9 @@ namespace Sass {
 
     std::string noPath("");
     Position noPosition(-1, -1, -1);
-    Complex_Selector* pFirst = SASS_MEMORY_NEW(ctx.mem, Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL);
+    Sequence_Selector* pFirst = SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, ParserState("[NODE]"), Sequence_Selector::ANCESTOR_OF, NULL, NULL);
 
-    Complex_Selector* pCurrent = pFirst;
+    Sequence_Selector* pCurrent = pFirst;
 
     if (toConvert.isSelector()) pFirst->has_line_feed(toConvert.got_line_feed);
     if (toConvert.isCombinator()) pFirst->has_line_feed(toConvert.got_line_feed);
@@ -257,11 +257,11 @@ namespace Sass {
         pCurrent->combinator(child.combinator());
         if (child.got_line_feed) pCurrent->has_line_feed(child.got_line_feed);
 
-        // if the next node is also a combinator, create another Complex_Selector to hold it so it doesn't replace the current combinator
+        // if the next node is also a combinator, create another Sequence_Selector to hold it so it doesn't replace the current combinator
         if (childIter+1 != childIterEnd) {
           Node& nextNode = *(childIter+1);
           if (nextNode.isCombinator()) {
-            pCurrent->tail(SASS_MEMORY_NEW(ctx.mem, Complex_Selector, ParserState("[NODE]"), Complex_Selector::ANCESTOR_OF, NULL, NULL));
+            pCurrent->tail(SASS_MEMORY_NEW(ctx.mem, Sequence_Selector, ParserState("[NODE]"), Sequence_Selector::ANCESTOR_OF, NULL, NULL));
             if (nextNode.got_line_feed) pCurrent->tail()->has_line_feed(nextNode.got_line_feed);
             pCurrent = pCurrent->tail();
           }
@@ -271,8 +271,8 @@ namespace Sass {
       }
     }
 
-    // Put the dummy Compound_Selector in the first position, for consistency with the rest of libsass
-    Compound_Selector* fakeHead = SASS_MEMORY_NEW(ctx.mem, Compound_Selector, ParserState("[NODE]"), 1);
+    // Put the dummy SimpleSequence_Selector in the first position, for consistency with the rest of libsass
+    SimpleSequence_Selector* fakeHead = SASS_MEMORY_NEW(ctx.mem, SimpleSequence_Selector, ParserState("[NODE]"), 1);
     Parent_Selector* selectorRef = SASS_MEMORY_NEW(ctx.mem, Parent_Selector, ParserState("[NODE]"));
     fakeHead->elements().push_back(selectorRef);
     if (toConvert.got_line_feed) pFirst->has_line_feed(toConvert.got_line_feed);
@@ -282,11 +282,11 @@ namespace Sass {
   }
 
   // A very naive trim function, which removes duplicates in a node
-  // This is only used in Complex_Selector::unify_with for now, may need modifications to fit other needs
+  // This is only used in Sequence_Selector::unify_with for now, may need modifications to fit other needs
   Node Node::naiveTrim(Node& seqses, Context& ctx) {
 
     std::vector<Node*> res;
-    std::vector<Complex_Selector*> known;
+    std::vector<Sequence_Selector*> known;
 
     NodeDeque::reverse_iterator seqsesIter = seqses.collection()->rbegin(),
                                 seqsesIterEnd = seqses.collection()->rend();
@@ -295,8 +295,8 @@ namespace Sass {
     {
       Node& seqs1 = *seqsesIter;
       if( seqs1.isSelector() ) {
-        Complex_Selector* sel = seqs1.selector();
-        std::vector<Complex_Selector*>::iterator it;
+        Sequence_Selector* sel = seqs1.selector();
+        std::vector<Sequence_Selector*>::iterator it;
         bool found = false;
         for (it = known.begin(); it != known.end(); ++it) {
           if (**it == *sel) { found = true; break; }