sassc 2.2.1 → 2.3.0

data/ext/libsass/src/file.cpp

@@ -13,7 +13,6 @@
 #else
 # include <unistd.h>
 #endif
-#include <cctype>
 #include <cstdio>
 #include <vector>
 #include <algorithm>
@@ -25,6 +24,7 @@
 #include "sass_functions.hpp"
 #include "error_handling.hpp"
 #include "util.hpp"
+#include "util_string.hpp"
 #include "sass2scss.h"
 
 #ifdef _WIN32
@@ -106,19 +106,19 @@ namespace Sass {
     bool is_absolute_path(const std::string& path)
     {
       #ifdef _WIN32
-        if (path.length() >= 2 && isalpha(path[0]) && path[1] == ':') return true;
+        if (path.length() >= 2 && Util::ascii_isalpha(path[0]) && path[1] == ':') return true;
       #endif
       size_t i = 0;
       // check if we have a protocol
-      if (path[i] && Prelexer::is_alpha(path[i])) {
+      if (path[i] && Util::ascii_isalpha(static_cast<unsigned char>(path[i]))) {
         // skip over all alphanumeric characters
-        while (path[i] && Prelexer::is_alnum(path[i])) ++i;
+        while (path[i] && Util::ascii_isalnum(static_cast<unsigned char>(path[i]))) ++i;
         i = i && path[i] == ':' ? i + 1 : 0;
       }
       return path[i] == '/';
     }
 
-    // helper function to find the last directory seperator
+    // helper function to find the last directory separator
     inline size_t find_last_folder_separator(const std::string& path, size_t limit = std::string::npos)
     {
       size_t pos;
@@ -173,15 +173,15 @@ namespace Sass {
       while((pos = path.find("/./", pos)) != std::string::npos) path.erase(pos, 2);
 
       // remove all leading and trailing self references
-      while(path.length() > 1 && path.substr(0, 2) == "./") path.erase(0, 2);
-      while((pos = path.length()) > 1 && path.substr(pos - 2) == "/.") path.erase(pos - 2);
+      while(path.size() >= 2 && path[0] == '.' && path[1] == '/') path.erase(0, 2);
+      while((pos = path.length()) > 1 && path[pos - 2] == '/' && path[pos - 1] == '.') path.erase(pos - 2);
 
 
       size_t proto = 0;
       // check if we have a protocol
-      if (path[proto] && Prelexer::is_alpha(path[proto])) {
+      if (path[proto] && Util::ascii_isalpha(static_cast<unsigned char>(path[proto]))) {
         // skip over all alphanumeric characters
-        while (path[proto] && Prelexer::is_alnum(path[proto++])) {}
+        while (path[proto] && Util::ascii_isalnum(static_cast<unsigned char>(path[proto++]))) {}
         // then skip over the mandatory colon
         if (proto && path[proto] == ':') ++ proto;
       }
@@ -260,9 +260,9 @@ namespace Sass {
 
       size_t proto = 0;
       // check if we have a protocol
-      if (path[proto] && Prelexer::is_alpha(path[proto])) {
+      if (path[proto] && Util::ascii_isalpha(static_cast<unsigned char>(path[proto]))) {
         // skip over all alphanumeric characters
-        while (path[proto] && Prelexer::is_alnum(path[proto++])) {}
+        while (path[proto] && Util::ascii_isalnum(static_cast<unsigned char>(path[proto++]))) {}
         // then skip over the mandatory colon
         if (proto && path[proto] == ':') ++ proto;
       }
@@ -288,7 +288,8 @@ namespace Sass {
         #else
           // compare the charactes in a case insensitive manner
           // windows fs is only case insensitive in ascii ranges
-          if (tolower(abs_path[i]) != tolower(abs_base[i])) break;
+          if (Util::ascii_tolower(static_cast<unsigned char>(abs_path[i])) !=
+              Util::ascii_tolower(static_cast<unsigned char>(abs_base[i]))) break;
         #endif
         if (abs_path[i] == '/') index = i + 1;
       }
@@ -474,6 +475,7 @@ namespace Sass {
         char* contents = static_cast<char*>(malloc(st.st_size + 2 * sizeof(char)));
         if (std::fread(static_cast<void*>(contents), 1, size, fd) != size) {
           free(contents);
+          std::fclose(fd);
           return nullptr;
         }
         if (std::fclose(fd) != 0) {
@@ -487,8 +489,7 @@ namespace Sass {
       if (path.length() > 5) {
         extension = path.substr(path.length() - 5, 5);
       }
-      for(size_t i=0; i<extension.size();++i)
-        extension[i] = tolower(extension[i]);
+      Util::ascii_str_tolower(&extension);
       if (extension == ".sass" && contents != 0) {
         char * converted = sass2scss(contents, SASS2SCSS_PRETTIFY_1 | SASS2SCSS_KEEP_COMMENT);
         free(contents); // free the indented contents

data/ext/libsass/src/file.hpp

@@ -1,6 +1,10 @@
 #ifndef SASS_FILE_H
 #define SASS_FILE_H
 
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
 #include <string>
 #include <vector>
 
@@ -100,7 +104,7 @@ namespace Sass {
     public:
       // the file contents
       char* contents;
-      // conected sourcemap
+      // connected sourcemap
       char* srcmap;
     public:
       Resource(char* contents, char* srcmap)
@@ -108,17 +112,6 @@ namespace Sass {
       { }
   };
 
-  // parsed stylesheet from loaded resource
-  class StyleSheet : public Resource {
-    public:
-      // parsed root block
-      Block_Obj root;
-    public:
-      StyleSheet(const Resource& res, Block_Obj root)
-      : Resource(res), root(root)
-      { }
-  };
-
   namespace File {
 
     static std::vector<std::string> defaultExtensions = { ".scss", ".sass", ".css" };

data/ext/libsass/src/fn_colors.cpp

@@ -2,12 +2,12 @@
 // __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
 
-#include <cctype>
 #include <iomanip>
 #include "ast.hpp"
 #include "fn_utils.hpp"
 #include "fn_colors.hpp"
 #include "util.hpp"
+#include "util_string.hpp"
 
 namespace Sass {
 
@@ -163,11 +163,11 @@ namespace Sass {
                              c1->a()*p + c2->a()*(1-p));
     }
 
-    Signature mix_sig = "mix($color-1, $color-2, $weight: 50%)";
+    Signature mix_sig = "mix($color1, $color2, $weight: 50%)";
     BUILT_IN(mix)
     {
-      Color_Obj  color1 = ARG("$color-1", Color);
-      Color_Obj  color2 = ARG("$color-2", Color);
+      Color_Obj  color1 = ARG("$color1", Color);
+      Color_Obj  color2 = ARG("$color2", Color);
       double weight = DARG_U_PRCT("$weight");
       return colormix(ctx, pstate, color1, color2, weight);
 
@@ -361,12 +361,16 @@ namespace Sass {
     {
       // CSS3 filter function overload: pass literal through directly
       Number* amount = Cast<Number>(env["$color"]);
+      double weight = DARG_U_PRCT("$weight");
       if (amount) {
+        // TODO: does not throw on 100% manually passed as value
+        if (weight < 100.0) {
+          error("Only one argument may be passed to the plain-CSS invert() function.", pstate, traces);
+        }
         return SASS_MEMORY_NEW(String_Quoted, pstate, "invert(" + amount->to_string(ctx.c_options) + ")");
       }
 
       Color* col = ARG("$color", Color);
-      double weight = DARG_U_PRCT("$weight");
       Color_RGBA_Obj inv = col->copyAsRGBA();
       inv->r(clip(255.0 - inv->r(), 0.0, 255.0));
       inv->g(clip(255.0 - inv->g(), 0.0, 255.0));
@@ -504,7 +508,7 @@ namespace Sass {
         double lscale = (l ? DARG_R_PRCT("$lightness") : 0.0) / 100.0;
         double ascale = (a ? DARG_R_PRCT("$alpha") : 0.0) / 100.0;
         if (hscale) c->h(c->h() + hscale * (hscale > 0.0 ? 360.0 - c->h() : c->h()));
-        if (sscale) c->s(c->s() + sscale * (sscale > 0.0 ? 100.0 - c->l() : c->s()));
+        if (sscale) c->s(c->s() + sscale * (sscale > 0.0 ? 100.0 - c->s() : c->s()));
         if (lscale) c->l(c->l() + lscale * (lscale > 0.0 ? 100.0 - c->l() : c->l()));
         if (ascale) c->a(c->a() + ascale * (ascale > 0.0 ? 1.0 - c->a() : c->a()));
         return c.detach();
@@ -582,10 +586,8 @@ namespace Sass {
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(g, ctx.c_options.precision));
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(Sass::round(b, ctx.c_options.precision));
 
-      std::string result(ss.str());
-      for (size_t i = 0, L = result.length(); i < L; ++i) {
-        result[i] = std::toupper(result[i]);
-      }
+      std::string result = ss.str();
+      Util::ascii_str_toupper(&result);
       return SASS_MEMORY_NEW(String_Quoted, pstate, result);
     }
 

data/ext/libsass/src/fn_lists.cpp

@@ -1,3 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
+#include "sass.hpp"
+
 #include "listize.hpp"
 #include "operators.hpp"
 #include "fn_utils.hpp"
@@ -31,8 +35,8 @@ namespace Sass {
     Signature length_sig = "length($list)";
     BUILT_IN(length)
     {
-      if (Selector_List* sl = Cast<Selector_List>(env["$list"])) {
-        return SASS_MEMORY_NEW(Number, pstate, (double)sl->length());
+      if (SelectorList * sl = Cast<SelectorList>(env["$list"])) {
+        return SASS_MEMORY_NEW(Number, pstate, (double) sl->length());
       }
       Expression* v = ARG("$list", Expression);
       if (v->concrete_type() == Expression::MAP) {
@@ -40,9 +44,9 @@ namespace Sass {
         return SASS_MEMORY_NEW(Number, pstate, (double)(map ? map->length() : 1));
       }
       if (v->concrete_type() == Expression::SELECTOR) {
-        if (Compound_Selector* h = Cast<Compound_Selector>(v)) {
+        if (CompoundSelector * h = Cast<CompoundSelector>(v)) {
           return SASS_MEMORY_NEW(Number, pstate, (double)h->length());
-        } else if (Selector_List* ls = Cast<Selector_List>(v)) {
+        } else if (SelectorList * ls = Cast<SelectorList>(v)) {
           return SASS_MEMORY_NEW(Number, pstate, (double)ls->length());
         } else {
           return SASS_MEMORY_NEW(Number, pstate, 1);
@@ -60,15 +64,13 @@ namespace Sass {
     {
       double nr = ARGVAL("$n");
       Map* m = Cast<Map>(env["$list"]);
-      if (Selector_List* sl = Cast<Selector_List>(env["$list"])) {
+      if (SelectorList * sl = Cast<SelectorList>(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, traces);
         double index = std::floor(nr < 0 ? len + nr : nr - 1);
         if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate, traces);
-        // return (*sl)[static_cast<int>(index)];
-        Listize listize;
-        return Cast<Value>((*sl)[static_cast<int>(index)]->perform(&listize));
+        return Cast<Value>(Listize::perform(sl->get(static_cast<int>(index))));
       }
       List_Obj l = Cast<List>(env["$list"]);
       if (nr == 0) error("argument `$n` of `" + std::string(sig) + "` must be non-zero", pstate, traces);
@@ -189,9 +191,8 @@ namespace Sass {
       Map_Obj m = Cast<Map>(env["$list"]);
       List_Obj l = Cast<List>(env["$list"]);
       Expression_Obj v = ARG("$val", Expression);
-      if (Selector_List* sl = Cast<Selector_List>(env["$list"])) {
-        Listize listize;
-        l = Cast<List>(sl->perform(&listize));
+      if (SelectorList * sl = Cast<SelectorList>(env["$list"])) {
+        l = Cast<List>(Listize::perform(sl));
       }
       String_Constant_Obj sep = ARG("$separator", String_Constant);
       if (!l) {

data/ext/libsass/src/fn_miscs.cpp

@@ -8,15 +8,6 @@ namespace Sass {
 
   namespace Functions {
 
-    // features
-    static std::set<std::string> features {
-      "global-variable-shadowing",
-      "extend-selector-pseudoclass",
-      "at-error",
-      "units-level-3",
-      "custom-property"
-    };
-
     //////////////////////////
     // INTROSPECTION FUNCTIONS
     //////////////////////////
@@ -85,34 +76,36 @@ namespace Sass {
       }
     }
 
-    Signature feature_exists_sig = "feature-exists($name)";
+    Signature feature_exists_sig = "feature-exists($feature)";
     BUILT_IN(feature_exists)
     {
-      std::string s = unquote(ARG("$name", String_Constant)->value());
-
-      if(features.find(s) == features.end()) {
-        return SASS_MEMORY_NEW(Boolean, pstate, false);
-      }
-      else {
-        return SASS_MEMORY_NEW(Boolean, pstate, true);
-      }
+      std::string s = unquote(ARG("$feature", String_Constant)->value());
+
+      static const auto *const features = new std::unordered_set<std::string> {
+        "global-variable-shadowing",
+        "extend-selector-pseudoclass",
+        "at-error",
+        "units-level-3",
+        "custom-property"
+      };
+      return SASS_MEMORY_NEW(Boolean, pstate, features->find(s) != features->end());
     }
 
-    Signature call_sig = "call($name, $args...)";
+    Signature call_sig = "call($function, $args...)";
     BUILT_IN(call)
     {
-      std::string name;
-      Function* ff = Cast<Function>(env["$name"]);
-      String_Constant* ss = Cast<String_Constant>(env["$name"]);
+      std::string function;
+      Function* ff = Cast<Function>(env["$function"]);
+      String_Constant* ss = Cast<String_Constant>(env["$function"]);
 
       if (ss) {
-        name = Util::normalize_underscores(unquote(ss->value()));
+        function = Util::normalize_underscores(unquote(ss->value()));
         std::cerr << "DEPRECATION WARNING: ";
         std::cerr << "Passing a string to call() is deprecated and will be illegal" << std::endl;
-        std::cerr << "in Sass 4.0. Use call(get-function(" + quote(name) + ")) instead." << std::endl;
+        std::cerr << "in Sass 4.0. Use call(get-function(" + quote(function) + ")) instead." << std::endl;
         std::cerr << std::endl;
       } else if (ff) {
-        name = ff->name();
+        function = ff->name();
       }
 
       List_Obj arglist = SASS_MEMORY_COPY(ARG("$args", List));
@@ -142,8 +135,9 @@ namespace Sass {
           args->append(SASS_MEMORY_NEW(Argument, pstate, expr));
         }
       }
-      Function_Call_Obj func = SASS_MEMORY_NEW(Function_Call, pstate, name, args);
-      Expand expand(ctx, &d_env, &selector_stack);
+      Function_Call_Obj func = SASS_MEMORY_NEW(Function_Call, pstate, function, args);
+
+      Expand expand(ctx, &d_env, &selector_stack, &original_stack);
       func->via_call(true); // calc invoke is allowed
       if (ff) func->func(ff);
       return Cast<PreValue>(func->perform(&expand.eval));
@@ -160,11 +154,9 @@ namespace Sass {
     }
 
     Signature if_sig = "if($condition, $if-true, $if-false)";
-    // BUILT_IN(sass_if)
-    // { return ARG("$condition", Expression)->is_false() ? ARG("$if-false", Expression) : ARG("$if-true", Expression); }
     BUILT_IN(sass_if)
     {
-      Expand expand(ctx, &d_env, &selector_stack);
+      Expand expand(ctx, &d_env, &selector_stack, &original_stack);
       Expression_Obj cond = ARG("$condition", Expression)->perform(&expand.eval);
       bool is_true = !cond->is_false();
       Expression_Obj res = ARG(is_true ? "$if-true" : "$if-false", Expression);
@@ -178,9 +170,6 @@ namespace Sass {
     // MISCELLANEOUS FUNCTIONS
     //////////////////////////
 
-    // value.check_deprecated_interp if value.is_a?(Sass::Script::Value::String)
-    // unquoted_string(value.to_sass)
-
     Signature inspect_sig = "inspect($value)";
     BUILT_IN(inspect)
     {
@@ -208,7 +197,6 @@ namespace Sass {
         ctx.c_options.output_style = old_style;
         return SASS_MEMORY_NEW(String_Quoted, pstate, i.get_buffer());
       }
-      // return v;
     }
 
     Signature content_exists_sig = "content-exists()";

data/ext/libsass/src/fn_numbers.cpp

@@ -5,7 +5,6 @@
 #include <cstdint>
 #include <cstdlib>
 #include <cmath>
-#include <cctype>
 #include <random>
 #include <sstream>
 #include <iomanip>
@@ -106,7 +105,11 @@ namespace Sass {
     {
       List* arglist = ARG("$numbers", List);
       Number_Obj least;
-      for (size_t i = 0, L = arglist->length(); i < L; ++i) {
+      size_t L = arglist->length();
+      if (L == 0) {
+        error("At least one argument must be passed.", pstate, traces);
+      }
+      for (size_t i = 0; i < L; ++i) {
         Expression_Obj val = arglist->value_at_index(i);
         Number_Obj xi = Cast<Number>(val);
         if (!xi) {
@@ -124,7 +127,11 @@ namespace Sass {
     {
       List* arglist = ARG("$numbers", List);
       Number_Obj greatest;
-      for (size_t i = 0, L = arglist->length(); i < L; ++i) {
+      size_t L = arglist->length();
+      if (L == 0) {
+        error("At least one argument must be passed.", pstate, traces);
+      }
+      for (size_t i = 0; i < L; ++i) {
         Expression_Obj val = arglist->value_at_index(i);
         Number_Obj xi = Cast<Number>(val);
         if (!xi) {
@@ -200,11 +207,11 @@ namespace Sass {
       return SASS_MEMORY_NEW(Boolean, pstate, unitless);
     }
 
-    Signature comparable_sig = "comparable($number-1, $number-2)";
+    Signature comparable_sig = "comparable($number1, $number2)";
     BUILT_IN(comparable)
     {
-      Number_Obj n1 = ARGN("$number-1");
-      Number_Obj n2 = ARGN("$number-2");
+      Number_Obj n1 = ARGN("$number1");
+      Number_Obj n2 = ARGN("$number2");
       if (n1->is_unitless() || n2->is_unitless()) {
         return SASS_MEMORY_NEW(Boolean, pstate, true);
       }

data/ext/libsass/src/fn_selectors.cpp

@@ -1,5 +1,8 @@
+#include <numeric>
+
 #include "parser.hpp"
-#include "extend.hpp"
+#include "extender.hpp"
+#include "listize.hpp"
 #include "fn_utils.hpp"
 #include "fn_selectors.hpp"
 
@@ -13,24 +16,27 @@ namespace Sass {
       List* arglist = ARG("$selectors", List);
 
       // Not enough parameters
-      if( arglist->length() == 0 )
-        error("$selectors: At least one selector must be passed for `selector-nest'", pstate, traces);
+      if (arglist->length() == 0) {
+        error(
+          "$selectors: At least one selector must be passed for `selector-nest'",
+          pstate, traces);
+      }
 
       // Parse args into vector of selectors
       SelectorStack parsedSelectors;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Expression_Obj exp = Cast<Expression>(arglist->value_at_index(i));
         if (exp->concrete_type() == Expression::NULL_VAL) {
-          std::stringstream msg;
-          msg << "$selectors: null is not a valid selector: it must be a string,\n";
-          msg << "a list of strings, or a list of lists of strings for 'selector-nest'";
-          error(msg.str(), pstate, traces);
+          error(
+            "$selectors: null is not a valid selector: it must be a string,\n"
+            "a list of strings, or a list of lists of strings for 'selector-nest'",
+            pstate, traces);
         }
         if (String_Constant_Obj str = Cast<String_Constant>(exp)) {
           str->quote_mark(0);
         }
         std::string exp_src = exp->to_string(ctx.c_options);
-        Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces);
+        SelectorListObj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces);
         parsedSelectors.push_back(sel);
       }
 
@@ -39,25 +45,21 @@ namespace Sass {
         return SASS_MEMORY_NEW(Null, pstate);
       }
 
-      // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
+      // Set the first element as the `result`, keep
+      // appending to as we go down the parsedSelector vector.
       SelectorStack::iterator itr = parsedSelectors.begin();
-      Selector_List_Obj result = *itr;
+      SelectorListObj& result = *itr;
       ++itr;
 
       for(;itr != parsedSelectors.end(); ++itr) {
-        Selector_List_Obj child = *itr;
-        std::vector<Complex_Selector_Obj> exploded;
-        selector_stack.push_back(result);
-        Selector_List_Obj rv = child->resolve_parent_refs(selector_stack, traces);
-        selector_stack.pop_back();
-        for (size_t m = 0, mLen = rv->length(); m < mLen; ++m) {
-          exploded.push_back((*rv)[m]);
-        }
-        result->elements(exploded);
+        SelectorListObj& child = *itr;
+        original_stack.push_back(result);
+        SelectorListObj rv = child->resolve_parent_refs(original_stack, traces);
+        result->elements(rv->elements());
+        original_stack.pop_back();
       }
 
-      Listize listize;
-      return Cast<Value>(result->perform(&listize));
+      return Cast<Value>(Listize::perform(result));
     }
 
     Signature selector_append_sig = "selector-append($selectors...)";
@@ -66,113 +68,96 @@ namespace Sass {
       List* arglist = ARG("$selectors", List);
 
       // Not enough parameters
-      if( arglist->length() == 0 )
-        error("$selectors: At least one selector must be passed for `selector-append'", pstate, traces);
+      if (arglist->empty()) {
+        error(
+          "$selectors: At least one selector must be "
+          "passed for `selector-append'",
+          pstate, traces);
+      }
 
       // Parse args into vector of selectors
       SelectorStack parsedSelectors;
+      parsedSelectors.push_back({});
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
-        Expression_Obj exp = Cast<Expression>(arglist->value_at_index(i));
+        Expression* exp = Cast<Expression>(arglist->value_at_index(i));
         if (exp->concrete_type() == Expression::NULL_VAL) {
-          std::stringstream msg;
-          msg << "$selectors: null is not a valid selector: it must be a string,\n";
-          msg << "a list of strings, or a list of lists of strings for 'selector-append'";
-          error(msg.str(), pstate, traces);
+          error(
+            "$selectors: null is not a valid selector: it must be a string,\n"
+             "a list of strings, or a list of lists of strings for 'selector-append'",
+            pstate, traces);
         }
         if (String_Constant* str = Cast<String_Constant>(exp)) {
           str->quote_mark(0);
         }
         std::string exp_src = exp->to_string();
-        Selector_List_Obj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces,
-                                                       exp->pstate(), pstate.src,
-                                                       /*allow_parent=*/false);
-
-        parsedSelectors.push_back(sel);
-      }
-
-      // Nothing to do
-      if( parsedSelectors.empty() ) {
-        return SASS_MEMORY_NEW(Null, pstate);
-      }
-
-      // Set the first element as the `result`, keep appending to as we go down the parsedSelector vector.
-      SelectorStack::iterator itr = parsedSelectors.begin();
-      Selector_List_Obj result = *itr;
-      ++itr;
-
-      for(;itr != parsedSelectors.end(); ++itr) {
-        Selector_List_Obj child = *itr;
-        std::vector<Complex_Selector_Obj> newElements;
-
-        // For every COMPLEX_SELECTOR in `result`
-        // For every COMPLEX_SELECTOR in `child`
-          // let parentSeqClone equal a copy of result->elements[i]
-          // let childSeq equal child->elements[j]
-          // Append all of childSeq head elements into parentSeqClone
-          // Set the innermost tail of parentSeqClone, to childSeq's tail
-        // 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_Obj parentSeqClone = SASS_MEMORY_CLONE((*result)[i]);
-            Complex_Selector_Obj childSeq = (*child)[j];
-            Complex_Selector_Obj base = childSeq->tail();
-
-            // Must be a simple sequence
-            if( childSeq->combinator() != Complex_Selector::Combinator::ANCESTOR_OF ) {
-              error("Can't append \"" + childSeq->to_string() + "\" to \"" +
-                parentSeqClone->to_string() + "\" for `selector-append'", pstate, traces);
-            }
+        SelectorListObj sel = Parser::parse_selector(exp_src.c_str(), ctx, traces,
+                                                     exp->pstate(), pstate.src,
+                                                     /*allow_parent=*/true);
 
-            // Cannot be a Universal selector
-            Type_Selector_Obj pType = Cast<Type_Selector>(childSeq->head()->first());
-            if(pType && pType->name() == "*") {
-              error("Can't append \"" + childSeq->to_string() + "\" to \"" +
-                parentSeqClone->to_string() + "\" for `selector-append'", pstate, traces);
-            }
+        for (auto& complex : sel->elements()) {
+          if (complex->empty()) {
+            complex->append(SASS_MEMORY_NEW(CompoundSelector, "[phony]"));
+          }
+          if (CompoundSelector* comp = Cast<CompoundSelector>(complex->first())) {
+            comp->hasRealParent(true);
+            complex->chroots(true);
+          }
+        }
 
-            // TODO: Add check for namespace stuff
+        if (parsedSelectors.size() > 1) {
 
-            Complex_Selector* lastComponent = parentSeqClone->mutable_last();
-            if (lastComponent->head() == nullptr) {
-              std::string msg = "Parent \"" + parentSeqClone->to_string() + "\" is incompatible with \"" + base->to_string() + "\"";
-              error(msg, pstate, traces);
+          if (!sel->has_real_parent_ref()) {
+            auto parent = parsedSelectors.back();
+            for (auto& complex : parent->elements()) {
+              if (CompoundSelector* comp = Cast<CompoundSelector>(complex->first())) {
+                comp->hasRealParent(false);
+              }
             }
-            lastComponent->head()->concat(base->head());
-            lastComponent->tail(base->tail());
-
-            newElements.push_back(parentSeqClone);
+            error("Can't append \"" + sel->to_string() + "\" to \"" +
+              parent->to_string() + "\" for `selector-append'",
+              pstate, traces);
           }
+
+          // Build the resolved stack from the left. It's cheaper to directly
+          // calculate and update each resolved selcted from the left, than to
+          // recursively calculate them from the right side, as we would need
+          // to go through the whole stack depth to build the final results.
+          // E.g. 'a', 'b', 'x, y' => 'a' => 'a b' => 'a b x, a b y'
+          // vs 'a', 'b', 'x, y' => 'x' => 'b x' => 'a b x', 'y' ...
+          parsedSelectors.push_back(sel->resolve_parent_refs(parsedSelectors, traces, true));
+        }
+        else {
+          parsedSelectors.push_back(sel);
         }
+      }
 
-        result->elements(newElements);
+      // Nothing to do
+      if( parsedSelectors.empty() ) {
+        return SASS_MEMORY_NEW(Null, pstate);
       }
 
-      Listize listize;
-      return Cast<Value>(result->perform(&listize));
+      return Cast<Value>(Listize::perform(parsedSelectors.back()));
     }
 
     Signature selector_unify_sig = "selector-unify($selector1, $selector2)";
     BUILT_IN(selector_unify)
     {
-      Selector_List_Obj selector1 = ARGSELS("$selector1");
-      Selector_List_Obj selector2 = ARGSELS("$selector2");
-
-      Selector_List_Obj result = selector1->unify_with(selector2);
-      Listize listize;
-      return Cast<Value>(result->perform(&listize));
+      SelectorListObj selector1 = ARGSELS("$selector1");
+      SelectorListObj selector2 = ARGSELS("$selector2");
+      SelectorListObj result = selector1->unifyWith(selector2);
+      return Cast<Value>(Listize::perform(result));
     }
 
     Signature simple_selectors_sig = "simple-selectors($selector)";
     BUILT_IN(simple_selectors)
     {
-      Compound_Selector_Obj sel = ARGSEL("$selector");
+      CompoundSelectorObj sel = ARGSEL("$selector");
 
       List* l = SASS_MEMORY_NEW(List, sel->pstate(), sel->length(), SASS_COMMA);
 
       for (size_t i = 0, L = sel->length(); i < L; ++i) {
-        Simple_Selector_Obj ss = (*sel)[i];
+        const SimpleSelectorObj& ss = sel->get(i);
         std::string ss_string = ss->to_string() ;
-
         l->append(SASS_MEMORY_NEW(String_Quoted, ss->pstate(), ss_string));
       }
 
@@ -182,51 +167,36 @@ namespace Sass {
     Signature selector_extend_sig = "selector-extend($selector, $extendee, $extender)";
     BUILT_IN(selector_extend)
     {
-      Selector_List_Obj  selector = ARGSELS("$selector");
-      Selector_List_Obj  extendee = ARGSELS("$extendee");
-      Selector_List_Obj  extender = ARGSELS("$extender");
-
-      Subset_Map subset_map;
-      extender->populate_extends(extendee, subset_map);
-      Extend extend(subset_map);
-
-      Selector_List_Obj result = extend.extendSelectorList(selector, false);
-
-      Listize listize;
-      return Cast<Value>(result->perform(&listize));
+      SelectorListObj selector = ARGSELS("$selector");
+      SelectorListObj target = ARGSELS("$extendee");
+      SelectorListObj source = ARGSELS("$extender");
+      SelectorListObj result = Extender::extend(selector, source, target, traces);
+      return Cast<Value>(Listize::perform(result));
     }
 
     Signature selector_replace_sig = "selector-replace($selector, $original, $replacement)";
     BUILT_IN(selector_replace)
     {
-      Selector_List_Obj selector = ARGSELS("$selector");
-      Selector_List_Obj original = ARGSELS("$original");
-      Selector_List_Obj replacement = ARGSELS("$replacement");
-      Subset_Map subset_map;
-      replacement->populate_extends(original, subset_map);
-      Extend extend(subset_map);
-
-      Selector_List_Obj result = extend.extendSelectorList(selector, true);
-
-      Listize listize;
-      return Cast<Value>(result->perform(&listize));
+      SelectorListObj selector = ARGSELS("$selector");
+      SelectorListObj target = ARGSELS("$original");
+      SelectorListObj source = ARGSELS("$replacement");
+      SelectorListObj result = Extender::replace(selector, source, target, traces);
+      return Cast<Value>(Listize::perform(result));
     }
 
     Signature selector_parse_sig = "selector-parse($selector)";
     BUILT_IN(selector_parse)
     {
-      Selector_List_Obj sel = ARGSELS("$selector");
-
-      Listize listize;
-      return Cast<Value>(sel->perform(&listize));
+      SelectorListObj selector = ARGSELS("$selector");
+      return Cast<Value>(Listize::perform(selector));
     }
 
     Signature is_superselector_sig = "is-superselector($super, $sub)";
     BUILT_IN(is_superselector)
     {
-      Selector_List_Obj  sel_sup = ARGSELS("$super");
-      Selector_List_Obj  sel_sub = ARGSELS("$sub");
-      bool result = sel_sup->is_superselector_of(sel_sub);
+      SelectorListObj sel_sup = ARGSELS("$super");
+      SelectorListObj sel_sub = ARGSELS("$sub");
+      bool result = sel_sup->isSuperselectorOf(sel_sub);
       return SASS_MEMORY_NEW(Boolean, pstate, result);
     }