sassc 1.10.1 → 1.11.0

data/ext/libsass/src/extend.hpp

@@ -2,6 +2,7 @@
 #define SASS_EXTEND_H
 
 #include <string>
+#include <set>
 
 #include "ast.hpp"
 #include "operation.hpp"
@@ -12,7 +13,7 @@ namespace Sass {
   class Context;
   class Node;
 
-  typedef Subset_Map<std::string, std::pair<Complex_Selector*, Compound_Selector*> > ExtensionSubsetMap;
+  typedef Subset_Map<std::string, std::pair<Sequence_Selector*, SimpleSequence_Selector*> > ExtensionSubsetMap;
 
   class Extend : public Operation_CRTP<void, Extend> {
 
@@ -23,11 +24,17 @@ namespace Sass {
 
   public:
     static Node subweave(Node& one, Node& two, Context& ctx);
-    static Selector_List* extendSelectorList(Selector_List* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething);
-    static Selector_List* extendSelectorList(Selector_List* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace = false) {
+    static CommaSequence_Selector* extendSelectorList(CommaSequence_Selector* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething, std::set<SimpleSequence_Selector>& seen);
+    static CommaSequence_Selector* extendSelectorList(CommaSequence_Selector* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace, bool& extendedSomething);
+    static CommaSequence_Selector* extendSelectorList(CommaSequence_Selector* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, bool isReplace = false) {
       bool extendedSomething = false;
       return extendSelectorList(pSelectorList, ctx, subset_map, isReplace, extendedSomething);
     }
+    static CommaSequence_Selector* extendSelectorList(CommaSequence_Selector* pSelectorList, Context& ctx, ExtensionSubsetMap& subset_map, std::set<SimpleSequence_Selector>& seen) {
+      bool isReplace = false;
+      bool extendedSomething = false;
+      return extendSelectorList(pSelectorList, ctx, subset_map, isReplace, extendedSomething, seen);
+    }
     Extend(Context&, ExtensionSubsetMap&);
     ~Extend() { }
 

data/ext/libsass/src/file.cpp

@@ -196,6 +196,7 @@ namespace Sass {
         bool is_slash = pos + 2 == L && (l[pos+1] == '/' || l[pos+1] == '\\');
         bool is_self = pos + 3 == L && (l[pos+1] == '.');
         if (!is_self && !is_slash) r = r.substr(3);
+        else if (pos == std::string::npos) break;
         l = l.substr(0, pos == std::string::npos ? pos : pos + 1);
       }
 
@@ -217,7 +218,7 @@ namespace Sass {
     // create an absolute path by resolving relative paths with cwd
     std::string rel2abs(const std::string& path, const std::string& base, const std::string& cwd)
     {
-      return make_canonical_path(join_paths(join_paths(cwd, base), path));
+      return make_canonical_path(join_paths(join_paths(cwd + "/", base + "/"), path));
     }
 
     // create a path that is relative to the given base directory

data/ext/libsass/src/functions.cpp

@@ -155,7 +155,7 @@ namespace Sass {
     T* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx);
 
     template <>
-    Selector_List* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
+    CommaSequence_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
       Expression* exp = ARG(argname, Expression);
       if (exp->concrete_type() == Expression::NULL_VAL) {
         std::stringstream msg;
@@ -171,7 +171,7 @@ namespace Sass {
     }
 
     template <>
-    Complex_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
+    Sequence_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
       Expression* exp = ARG(argname, Expression);
       if (exp->concrete_type() == Expression::NULL_VAL) {
         std::stringstream msg;
@@ -183,12 +183,12 @@ namespace Sass {
         str->quote_mark(0);
       }
       std::string exp_src = exp->to_string(ctx.c_options) + "{";
-      Selector_List* sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
+      CommaSequence_Selector* sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
       return (sel_list->length() > 0) ? sel_list->first() : 0;
     }
 
     template <>
-    Compound_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
+    SimpleSequence_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
       Expression* exp = ARG(argname, Expression);
       if (exp->concrete_type() == Expression::NULL_VAL) {
         std::stringstream msg;
@@ -199,7 +199,7 @@ namespace Sass {
         str->quote_mark(0);
       }
       std::string exp_src = exp->to_string(ctx.c_options) + "{";
-      Selector_List* sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
+      CommaSequence_Selector* sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
       return (sel_list->length() > 0) ? sel_list->first()->tail()->head() : 0;
     }
 
@@ -385,6 +385,12 @@ namespace Sass {
       while (h < 0) h += 1;
       while (h > 1) h -= 1;
 
+      // if saturation is exacly zero, we loose
+      // information for hue, since it will evaluate
+      // to zero if converted back from rgb. Setting
+      // saturation to a very tiny number solves this.
+      if (s == 0) s = 1e-10;
+
       // Algorithm from the CSS3 spec: http://www.w3.org/TR/css3-color/#hsl-color.
       double m2;
       if (l <= 0.5) m2 = l*(s+1.0);
@@ -819,7 +825,7 @@ namespace Sass {
       }
       if (hsl) {
         HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());
-        if (h) hsl_struct.h = static_cast<double>(((static_cast<int>(h->value()) % 360) + 360) % 360) / 360.0;
+        if (h) hsl_struct.h = std::fmod(h->value(), 360.0);
         if (s) hsl_struct.s = ARGR("$saturation", Number, 0, 100)->value();
         if (l) hsl_struct.l = ARGR("$lightness",  Number, 0, 100)->value();
         double alpha = a ? ARGR("$alpha", Number, 0, 1.0)->value() : color->a();
@@ -880,7 +886,7 @@ namespace Sass {
       if (String_Quoted* string_quoted = dynamic_cast<String_Quoted*>(arg)) {
         String_Constant* result = SASS_MEMORY_NEW(ctx.mem, String_Constant, pstate, string_quoted->value());
         // remember if the string was quoted (color tokens)
-        result->sass_fix_1291(string_quoted->quote_mark() != 0);
+        result->is_delayed(true); // delay colors
         return result;
       }
       else if (dynamic_cast<String_Constant*>(arg)) {
@@ -910,7 +916,6 @@ namespace Sass {
       // all other nodes must be converted to a string node
       std::string str(quote(arg->to_string(ctx.c_options), String_Constant::double_quote()));
       String_Quoted* result = SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
-      result->is_delayed(true);
       result->quote_mark('*');
       return result;
     }
@@ -1015,8 +1020,14 @@ namespace Sass {
         std::string str = unquote(s->value());
 
         size_t size = utf8::distance(str.begin(), str.end());
-        if (end_at <= size * -1.0) { end_at += size; }
-        if (end_at < 0) { end_at += size + 1; }
+        if (end_at <= size * -1.0 && size > 1) {
+          end_at += size;
+          if (end_at == 0) end_at = 1;
+        }
+        if (end_at < 0) {
+          end_at += size + 1;
+          if (end_at == 0) end_at = 1;
+        }
         if (end_at > size) { end_at = (double)size; }
         if (start_at < 0) { start_at += size + 1; }
         else if (start_at == 0) { ++ start_at; }
@@ -1212,7 +1223,7 @@ namespace Sass {
     Signature length_sig = "length($list)";
     BUILT_IN(length)
     {
-      if (Selector_List* sl = dynamic_cast<Selector_List*>(env["$list"])) {
+      if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(env["$list"])) {
         return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)sl->length());
       }
       Expression* v = ARG("$list", Expression);
@@ -1221,9 +1232,9 @@ namespace Sass {
         return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)(map ? map->length() : 1));
       }
       if (v->concrete_type() == Expression::SELECTOR) {
-        if (Compound_Selector* h = dynamic_cast<Compound_Selector*>(v)) {
+        if (SimpleSequence_Selector* h = dynamic_cast<SimpleSequence_Selector*>(v)) {
           return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)h->length());
-        } else if (Selector_List* ls = dynamic_cast<Selector_List*>(v)) {
+        } else if (CommaSequence_Selector* ls = dynamic_cast<CommaSequence_Selector*>(v)) {
           return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)ls->length());
         } else {
           return SASS_MEMORY_NEW(ctx.mem, Number, pstate, 1);
@@ -1241,7 +1252,7 @@ namespace Sass {
     {
       Number* n = ARG("$n", Number);
       Map* m = dynamic_cast<Map*>(env["$list"]);
-      if (Selector_List* sl = dynamic_cast<Selector_List*>(env["$list"])) {
+      if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(env["$list"])) {
         size_t len = m ? m->length() : sl->length();
         bool empty = m ? m->empty() : sl->empty();
         if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate);
@@ -1271,13 +1282,16 @@ namespace Sass {
         return l;
       }
       else {
-        return l->value_at_index(static_cast<int>(index));
+        Expression* rv = l->value_at_index(static_cast<int>(index));
+        rv->set_delayed(false);
+        return rv;
       }
     }
 
     Signature set_nth_sig = "set-nth($list, $n, $value)";
     BUILT_IN(set_nth)
     {
+      Map* m = dynamic_cast<Map*>(env["$list"]);
       List* l = dynamic_cast<List*>(env["$list"]);
       Number* n = ARG("$n", Number);
       Expression* v = ARG("$value", Expression);
@@ -1285,6 +1299,9 @@ namespace Sass {
         l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l << ARG("$list", Expression);
       }
+      if (m) {
+        l = m->to_list(ctx, pstate);
+      }
       if (l->empty()) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate);
       double index = std::floor(n->value() < 0 ? l->length() + n->value() : n->value() - 1);
       if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
@@ -1298,12 +1315,16 @@ namespace Sass {
     Signature index_sig = "index($list, $value)";
     BUILT_IN(index)
     {
+      Map* m = dynamic_cast<Map*>(env["$list"]);
       List* l = dynamic_cast<List*>(env["$list"]);
       Expression* v = ARG("$value", Expression);
       if (!l) {
         l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l << ARG("$list", Expression);
       }
+      if (m) {
+        l = m->to_list(ctx, pstate);
+      }
       for (size_t i = 0, L = l->length(); i < L; ++i) {
         if (Eval::eq(l->value_at_index(i), v)) return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)(i+1));
       }
@@ -1313,6 +1334,8 @@ namespace Sass {
     Signature join_sig = "join($list1, $list2, $separator: auto)";
     BUILT_IN(join)
     {
+      Map* m1 = dynamic_cast<Map*>(env["$list1"]);
+      Map* m2 = dynamic_cast<Map*>(env["$list2"]);
       List* l1 = dynamic_cast<List*>(env["$list1"]);
       List* l2 = dynamic_cast<List*>(env["$list2"]);
       String_Constant* sep = ARG("$separator", String_Constant);
@@ -1326,6 +1349,13 @@ namespace Sass {
         l2 = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l2 << ARG("$list2", Expression);
       }
+      if (m1) {
+        l1 = m1->to_list(ctx, pstate);
+        sep_val = SASS_COMMA;
+      }
+      if (m2) {
+        l2 = m2->to_list(ctx, pstate);
+      }
       size_t len = l1->length() + l2->length();
       std::string sep_str = unquote(sep->value());
       if (sep_str == "space") sep_val = SASS_SPACE;
@@ -1340,9 +1370,10 @@ namespace Sass {
     Signature append_sig = "append($list, $val, $separator: auto)";
     BUILT_IN(append)
     {
+      Map* m = dynamic_cast<Map*>(env["$list"]);
       List* l = dynamic_cast<List*>(env["$list"]);
       Expression* v = ARG("$val", Expression);
-      if (Selector_List* sl = dynamic_cast<Selector_List*>(env["$list"])) {
+      if (CommaSequence_Selector* sl = dynamic_cast<CommaSequence_Selector*>(env["$list"])) {
         Listize listize(ctx.mem);
         l = dynamic_cast<List*>(sl->perform(&listize));
       }
@@ -1351,6 +1382,9 @@ namespace Sass {
         l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l << ARG("$list", Expression);
       }
+      if (m) {
+        l = m->to_list(ctx, pstate);
+      }
       List* result = SASS_MEMORY_NEW(ctx.mem, List, pstate, l->length() + 1, l->separator());
       std::string sep_str(unquote(sep->value()));
       if (sep_str == "space") result->separator(SASS_SPACE);
@@ -1380,9 +1414,14 @@ namespace Sass {
       size_t shortest = 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         List* ith = dynamic_cast<List*>(arglist->value_at_index(i));
+        Map* mith = dynamic_cast<Map*>(arglist->value_at_index(i));
         if (!ith) {
-          ith = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
-          *ith << arglist->value_at_index(i);
+          if (mith) {
+            ith = mith->to_list(ctx, pstate);
+          } else {
+            ith = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
+            *ith << arglist->value_at_index(i);
+          }
           if (arglist->is_arglist()) {
             ((Argument*)(*arglist)[i])->value(ith);
           } else {
@@ -1636,7 +1675,7 @@ namespace Sass {
         }
       }
       Function_Call* func = SASS_MEMORY_NEW(ctx.mem, Function_Call, pstate, name, args);
-      Expand expand(ctx, &d_env, backtrace);
+      Expand expand(ctx, &d_env, backtrace, &selector_stack);
       return func->perform(&expand.eval);
 
     }
@@ -1654,14 +1693,12 @@ namespace Sass {
     // { return ARG("$condition", Expression)->is_false() ? ARG("$if-false", Expression) : ARG("$if-true", Expression); }
     BUILT_IN(sass_if)
     {
-      Expand expand(ctx, &d_env, backtrace);
+      Expand expand(ctx, &d_env, backtrace, &selector_stack);
       bool is_true = !ARG("$condition", Expression)->perform(&expand.eval)->is_false();
-      if (is_true) {
-        return ARG("$if-true", Expression)->perform(&expand.eval);
-      }
-      else {
-        return ARG("$if-false", Expression)->perform(&expand.eval);
-      }
+      Expression* res = ARG(is_true ? "$if-true" : "$if-false", Expression);
+      res = res->perform(&expand.eval);
+      res->set_delayed(false); // clone?
+      return res;
     }
 
     ////////////////
@@ -1716,7 +1753,7 @@ namespace Sass {
         error("$selectors: At least one selector must be passed", pstate);
 
       // Parse args into vector of selectors
-      std::vector<Selector_List*> parsedSelectors;
+      std::vector<CommaSequence_Selector*> parsedSelectors;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Expression* exp = dynamic_cast<Expression*>(arglist->value_at_index(i));
         if (exp->concrete_type() == Expression::NULL_VAL) {
@@ -1729,7 +1766,7 @@ namespace Sass {
           str->quote_mark(0);
         }
         std::string exp_src = exp->to_string(ctx.c_options) + "{";
-        Selector_List* sel = Parser::parse_selector(exp_src.c_str(), ctx);
+        CommaSequence_Selector* sel = Parser::parse_selector(exp_src.c_str(), ctx);
         parsedSelectors.push_back(sel);
       }
 
@@ -1739,14 +1776,14 @@ namespace Sass {
       }
 
       // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
-      std::vector<Selector_List*>::iterator itr = parsedSelectors.begin();
-      Selector_List* result = *itr;
+      std::vector<CommaSequence_Selector*>::iterator itr = parsedSelectors.begin();
+      CommaSequence_Selector* result = *itr;
       ++itr;
 
       for(;itr != parsedSelectors.end(); ++itr) {
-        Selector_List* child = *itr;
-        std::vector<Complex_Selector*> exploded;
-        Selector_List* rv = child->parentize(result, ctx);
+        CommaSequence_Selector* child = *itr;
+        std::vector<Sequence_Selector*> exploded;
+        CommaSequence_Selector* rv = child->resolve_parent_refs(ctx, result);
         for (size_t m = 0, mLen = rv->length(); m < mLen; ++m) {
           exploded.push_back((*rv)[m]);
         }
@@ -1767,7 +1804,7 @@ namespace Sass {
         error("$selectors: At least one selector must be passed", pstate);
 
       // Parse args into vector of selectors
-      std::vector<Selector_List*> parsedSelectors;
+      std::vector<CommaSequence_Selector*> parsedSelectors;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Expression* exp = dynamic_cast<Expression*>(arglist->value_at_index(i));
         if (exp->concrete_type() == Expression::NULL_VAL) {
@@ -1780,7 +1817,7 @@ namespace Sass {
           str->quote_mark(0);
         }
         std::string exp_src = exp->to_string() + "{";
-        Selector_List* sel = Parser::parse_selector(exp_src.c_str(), ctx);
+        CommaSequence_Selector* sel = Parser::parse_selector(exp_src.c_str(), ctx);
         parsedSelectors.push_back(sel);
       }
 
@@ -1790,13 +1827,13 @@ namespace Sass {
       }
 
       // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
-      std::vector<Selector_List*>::iterator itr = parsedSelectors.begin();
-      Selector_List* result = *itr;
+      std::vector<CommaSequence_Selector*>::iterator itr = parsedSelectors.begin();
+      CommaSequence_Selector* result = *itr;
       ++itr;
 
       for(;itr != parsedSelectors.end(); ++itr) {
-        Selector_List* child = *itr;
-        std::vector<Complex_Selector*> newElements;
+        CommaSequence_Selector* child = *itr;
+        std::vector<Sequence_Selector*> newElements;
 
         // For every COMPLEX_SELECTOR in `result`
         // For every COMPLEX_SELECTOR in `child`
@@ -1807,12 +1844,12 @@ namespace Sass {
         // Replace result->elements with newElements
         for (size_t i = 0, resultLen = result->length(); i < resultLen; ++i) {
           for (size_t j = 0, childLen = child->length(); j < childLen; ++j) {
-            Complex_Selector* parentSeqClone = (*result)[i]->cloneFully(ctx);
-            Complex_Selector* childSeq = (*child)[j];
-            Complex_Selector* base = childSeq->tail();
+            Sequence_Selector* parentSeqClone = (*result)[i]->cloneFully(ctx);
+            Sequence_Selector* childSeq = (*child)[j];
+            Sequence_Selector* base = childSeq->tail();
 
             // Must be a simple sequence
-            if( childSeq->combinator() != Complex_Selector::Combinator::ANCESTOR_OF ) {
+            if( childSeq->combinator() != Sequence_Selector::Combinator::ANCESTOR_OF ) {
               std::string msg("Can't append  `");
               msg += childSeq->to_string();
               msg += "` to `";
@@ -1822,7 +1859,7 @@ namespace Sass {
             }
 
             // Cannot be a Universal selector
-            Type_Selector* pType = dynamic_cast<Type_Selector*>(childSeq->head()->first());
+            Element_Selector* pType = dynamic_cast<Element_Selector*>(childSeq->head()->first());
             if(pType && pType->name() == "*") {
               std::string msg("Can't append  `");
               msg += childSeq->to_string();
@@ -1854,10 +1891,10 @@ namespace Sass {
     Signature selector_unify_sig = "selector-unify($selector1, $selector2)";
     BUILT_IN(selector_unify)
     {
-      Selector_List* selector1 = ARGSEL("$selector1", Selector_List, p_contextualize);
-      Selector_List* selector2 = ARGSEL("$selector2", Selector_List, p_contextualize);
+      CommaSequence_Selector* selector1 = ARGSEL("$selector1", CommaSequence_Selector, p_contextualize);
+      CommaSequence_Selector* selector2 = ARGSEL("$selector2", CommaSequence_Selector, p_contextualize);
 
-      Selector_List* result = selector1->unify_with(selector2, ctx);
+      CommaSequence_Selector* result = selector1->unify_with(selector2, ctx);
       Listize listize(ctx.mem);
       return result->perform(&listize);
     }
@@ -1865,7 +1902,7 @@ namespace Sass {
     Signature simple_selectors_sig = "simple-selectors($selector)";
     BUILT_IN(simple_selectors)
     {
-      Compound_Selector* sel = ARGSEL("$selector", Compound_Selector, p_contextualize);
+      SimpleSequence_Selector* sel = ARGSEL("$selector", SimpleSequence_Selector, p_contextualize);
 
       List* l = SASS_MEMORY_NEW(ctx.mem, List, sel->pstate(), sel->length(), SASS_COMMA);
 
@@ -1882,14 +1919,14 @@ namespace Sass {
     Signature selector_extend_sig = "selector-extend($selector, $extendee, $extender)";
     BUILT_IN(selector_extend)
     {
-      Selector_List*  selector = ARGSEL("$selector", Selector_List, p_contextualize);
-      Selector_List*  extendee = ARGSEL("$extendee", Selector_List, p_contextualize);
-      Selector_List*  extender = ARGSEL("$extender", Selector_List, p_contextualize);
+      CommaSequence_Selector*  selector = ARGSEL("$selector", CommaSequence_Selector, p_contextualize);
+      CommaSequence_Selector*  extendee = ARGSEL("$extendee", CommaSequence_Selector, p_contextualize);
+      CommaSequence_Selector*  extender = ARGSEL("$extender", CommaSequence_Selector, p_contextualize);
 
       ExtensionSubsetMap subset_map;
       extender->populate_extends(extendee, ctx, subset_map);
 
-      Selector_List* result = Extend::extendSelectorList(selector, ctx, subset_map, false);
+      CommaSequence_Selector* result = Extend::extendSelectorList(selector, ctx, subset_map, false);
 
       Listize listize(ctx.mem);
       return result->perform(&listize);
@@ -1898,14 +1935,14 @@ namespace Sass {
     Signature selector_replace_sig = "selector-replace($selector, $original, $replacement)";
     BUILT_IN(selector_replace)
     {
-      Selector_List*  selector = ARGSEL("$selector", Selector_List, p_contextualize);
-      Selector_List*  original = ARGSEL("$original", Selector_List, p_contextualize);
-      Selector_List*  replacement = ARGSEL("$replacement", Selector_List, p_contextualize);
+      CommaSequence_Selector*  selector = ARGSEL("$selector", CommaSequence_Selector, p_contextualize);
+      CommaSequence_Selector*  original = ARGSEL("$original", CommaSequence_Selector, p_contextualize);
+      CommaSequence_Selector*  replacement = ARGSEL("$replacement", CommaSequence_Selector, p_contextualize);
 
       ExtensionSubsetMap subset_map;
       replacement->populate_extends(original, ctx, subset_map);
 
-      Selector_List* result = Extend::extendSelectorList(selector, ctx, subset_map, true);
+      CommaSequence_Selector* result = Extend::extendSelectorList(selector, ctx, subset_map, true);
 
       Listize listize(ctx.mem);
       return result->perform(&listize);
@@ -1914,7 +1951,7 @@ namespace Sass {
     Signature selector_parse_sig = "selector-parse($selector)";
     BUILT_IN(selector_parse)
     {
-      Selector_List* sel = ARGSEL("$selector", Selector_List, p_contextualize);
+      CommaSequence_Selector* sel = ARGSEL("$selector", CommaSequence_Selector, p_contextualize);
 
       Listize listize(ctx.mem);
       return sel->perform(&listize);
@@ -1923,8 +1960,8 @@ namespace Sass {
     Signature is_superselector_sig = "is-superselector($super, $sub)";
     BUILT_IN(is_superselector)
     {
-      Selector_List*  sel_sup = ARGSEL("$super", Selector_List, p_contextualize);
-      Selector_List*  sel_sub = ARGSEL("$sub", Selector_List, p_contextualize);
+      CommaSequence_Selector*  sel_sup = ARGSEL("$super", CommaSequence_Selector, p_contextualize);
+      CommaSequence_Selector*  sel_sub = ARGSEL("$sub", CommaSequence_Selector, p_contextualize);
       bool result = sel_sup->is_superselector_of(sel_sub);
       return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, result);
     }