sassc 1.7.1 → 1.8.0.pre1

data/ext/libsass/{functions.cpp → src/functions.cpp}

@@ -6,8 +6,10 @@
 #include "constants.hpp"
 #include "to_string.hpp"
 #include "inspect.hpp"
+#include "extend.hpp"
 #include "eval.hpp"
 #include "util.hpp"
+#include "expand.hpp"
 #include "utf8_string.hpp"
 #include "utf8.h"
 
@@ -39,19 +41,21 @@ namespace Sass {
   {
     Parser sig_parser = Parser::from_c_str(sig, ctx, ParserState("[built-in function]"));
     sig_parser.lex<Prelexer::identifier>();
-    string name(Util::normalize_underscores(sig_parser.lexed));
+    std::string name(Util::normalize_underscores(sig_parser.lexed));
     Parameters* params = sig_parser.parse_parameters();
-    return new (ctx.mem) Definition(ParserState("[built-in function]"),
-                                    sig,
-                                    name,
-                                    params,
-                                    func,
-                                    &ctx,
-                                    false);
+    return SASS_MEMORY_NEW(ctx.mem, Definition,
+                           ParserState("[built-in function]"),
+                           sig,
+                           name,
+                           params,
+                           func,
+                           false);
   }
 
   Definition* make_c_function(Sass_Function_Entry c_func, Context& ctx)
   {
+    using namespace Prelexer;
+
     const char* sig = sass_function_get_signature(c_func);
     Parser sig_parser = Parser::from_c_str(sig, ctx, ParserState("[c function]"));
     // allow to overload generic callback plus @warn, @error and @debug with custom functions
@@ -60,26 +64,52 @@ namespace Sass {
                                     exactly < Constants::error_kwd >,
                                     exactly < Constants::debug_kwd >
                    >              >();
-    string name(Util::normalize_underscores(sig_parser.lexed));
+    std::string name(Util::normalize_underscores(sig_parser.lexed));
     Parameters* params = sig_parser.parse_parameters();
-    return new (ctx.mem) Definition(ParserState("[c function]"),
-                                    sig,
-                                    name,
-                                    params,
-                                    c_func,
-                                    &ctx,
-                                    false, true);
+    return SASS_MEMORY_NEW(ctx.mem, Definition,
+                           ParserState("[c function]"),
+                           sig,
+                           name,
+                           params,
+                           c_func,
+                           false, true);
+  }
+
+  std::string function_name(Signature sig)
+  {
+    std::string str(sig);
+    return str.substr(0, str.find('('));
   }
 
   namespace Functions {
 
+    inline void handle_utf8_error (const ParserState& pstate, Backtrace* backtrace)
+    {
+      try {
+       throw;
+      }
+      catch (utf8::invalid_code_point) {
+        std::string msg("utf8::invalid_code_point");
+        error(msg, pstate, backtrace);
+      }
+      catch (utf8::not_enough_room) {
+        std::string msg("utf8::not_enough_room");
+        error(msg, pstate, backtrace);
+      }
+      catch (utf8::invalid_utf8) {
+        std::string msg("utf8::invalid_utf8");
+        error(msg, pstate, backtrace);
+      }
+      catch (...) { throw; }
+    }
+
     template <typename T>
-    T* get_arg(const string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace)
+    T* get_arg(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace)
     {
       // Minimal error handling -- the expectation is that built-ins will be written correctly!
       T* val = dynamic_cast<T*>(env[argname]);
       if (!val) {
-        string msg("argument `");
+        std::string msg("argument `");
         msg += argname;
         msg += "` of `";
         msg += sig;
@@ -90,27 +120,27 @@ namespace Sass {
       return val;
     }
 
-    Map* get_arg_m(const string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx)
+    Map* get_arg_m(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx)
     {
       // Minimal error handling -- the expectation is that built-ins will be written correctly!
       Map* val = dynamic_cast<Map*>(env[argname]);
       if (val) return val;
 
       List* lval = dynamic_cast<List*>(env[argname]);
-      if (lval && lval->length() == 0) return new (ctx.mem) Map(pstate, 0);
+      if (lval && lval->length() == 0) return SASS_MEMORY_NEW(ctx.mem, Map, pstate, 0);
 
       // fallback on get_arg for error handling
       val = get_arg<Map>(argname, env, sig, pstate, backtrace);
       return val;
     }
 
-    Number* get_arg_r(const string& argname, Env& env, Signature sig, ParserState pstate, double lo, double hi, Backtrace* backtrace)
+    Number* get_arg_r(const std::string& argname, Env& env, Signature sig, ParserState pstate, double lo, double hi, Backtrace* backtrace)
     {
       // Minimal error handling -- the expectation is that built-ins will be written correctly!
       Number* val = get_arg<Number>(argname, env, sig, pstate, backtrace);
       double v = val->value();
       if (!(lo <= v && v <= hi)) {
-        stringstream msg;
+        std::stringstream msg;
         msg << "argument `" << argname << "` of `" << sig << "` must be between ";
         msg << lo << " and " << hi;
         error(msg.str(), pstate, backtrace);
@@ -118,7 +148,55 @@ namespace Sass {
       return val;
     }
 
-#ifdef __MINGW32__
+    #define ARGSEL(argname, seltype, contextualize) get_arg_sel<seltype>(argname, env, sig, pstate, backtrace, ctx)
+
+    template <typename T>
+    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) {
+      To_String to_string(&ctx, false);
+      Expression* exp = ARG(argname, Expression);
+      if (exp->concrete_type() == Expression::NULL_VAL) {
+        std::stringstream msg;
+        msg << argname << ": 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 `" << function_name(sig) << "'";
+        error(msg.str(), pstate);
+      }
+      std::string exp_src = exp->perform(&to_string) + "{";
+      return Parser::parse_selector(exp_src.c_str(), ctx);
+    }
+
+    template <>
+    Complex_Selector* get_arg_sel(const std::string& argname, Env& env, Signature sig, ParserState pstate, Backtrace* backtrace, Context& ctx) {
+      To_String to_string(&ctx, false);
+      Expression* exp = ARG(argname, Expression);
+      if (exp->concrete_type() == Expression::NULL_VAL) {
+        std::stringstream msg;
+        msg << argname << ": 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 `" << function_name(sig) << "'";
+        error(msg.str(), pstate);
+      }
+      std::string exp_src = exp->perform(&to_string) + "{";
+      Selector_List* 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) {
+      To_String to_string(&ctx, false);
+      Expression* exp = ARG(argname, Expression);
+      if (exp->concrete_type() == Expression::NULL_VAL) {
+        std::stringstream msg;
+        msg << argname << ": null is not a string for `" << function_name(sig) << "'";
+        error(msg.str(), pstate);
+      }
+      std::string exp_src = exp->perform(&to_string) + "{";
+      Selector_List* sel_list = Parser::parse_selector(exp_src.c_str(), ctx);
+      return (sel_list->length() > 0) ? sel_list->first()->tail()->head() : 0;
+    }
+
+    #ifdef __MINGW32__
     uint64_t GetSeed()
     {
       HCRYPTPROV hp = 0;
@@ -132,23 +210,24 @@ namespace Sass {
 
       return seed;
     }
-#else
-    static random_device rd;
+    #else
+    static std::random_device rd;
     uint64_t GetSeed()
     {
-	  return rd();
-	}
-#endif
+      return rd();
+    }
+    #endif
 
     // note: the performance of many  implementations of
     // random_device degrades sharply once the entropy pool
     // is exhausted. For practical use, random_device is
     // generally only used to seed a PRNG such as mt19937.
-    static mt19937 rand(static_cast<unsigned int>(GetSeed()));
+    static std::mt19937 rand(static_cast<unsigned int>(GetSeed()));
 
     // features
-    static set<string> features {
+    static std::set<std::string> features {
       "global-variable-shadowing",
+      "extend-selector-pseudoclass",
       "at-error",
       "units-level-3"
     };
@@ -159,52 +238,62 @@ namespace Sass {
 
     inline double color_num(Number* n) {
       if (n->unit() == "%") {
-        return std::min(std::max(n->value(), 0.0), 1.0) * 255;
+        return std::min(std::max(n->value() * 255 / 100.0, 0.0), 255.0);
       } else {
         return std::min(std::max(n->value(), 0.0), 255.0);
       }
     }
 
+    inline double alpha_num(Number* n) {
+      if (n->unit() == "%") {
+        return std::min(std::max(n->value(), 0.0), 100.0);
+      } else {
+        return std::min(std::max(n->value(), 0.0), 1.0);
+      }
+    }
+
     Signature rgb_sig = "rgb($red, $green, $blue)";
     BUILT_IN(rgb)
     {
-      return new (ctx.mem) Color(pstate,
-                                 color_num(ARGR("$red",   Number, 0, 255)),
-                                 color_num(ARGR("$green", Number, 0, 255)),
-                                 color_num(ARGR("$blue",  Number, 0, 255)));
+      return SASS_MEMORY_NEW(ctx.mem, Color,
+                             pstate,
+                             color_num(ARG("$red",   Number)),
+                             color_num(ARG("$green", Number)),
+                             color_num(ARG("$blue",  Number)));
     }
 
     Signature rgba_4_sig = "rgba($red, $green, $blue, $alpha)";
     BUILT_IN(rgba_4)
     {
-      return new (ctx.mem) Color(pstate,
-                                 color_num(ARGR("$red",   Number, 0, 255)),
-                                 color_num(ARGR("$green", Number, 0, 255)),
-                                 color_num(ARGR("$blue",  Number, 0, 255)),
-                                 ARGR("$alpha", Number, 0, 1)->value());
+      return SASS_MEMORY_NEW(ctx.mem, Color,
+                             pstate,
+                             color_num(ARG("$red",   Number)),
+                             color_num(ARG("$green", Number)),
+                             color_num(ARG("$blue",  Number)),
+                             alpha_num(ARG("$alpha", Number)));
     }
 
     Signature rgba_2_sig = "rgba($color, $alpha)";
     BUILT_IN(rgba_2)
     {
       Color* c_arg = ARG("$color", Color);
-      Color* new_c = new (ctx.mem) Color(*c_arg);
-      new_c->a(ARGR("$alpha", Number, 0, 1)->value());
+      Color* new_c = SASS_MEMORY_NEW(ctx.mem, Color, *c_arg);
+      new_c->a(alpha_num(ARG("$alpha", Number)));
       new_c->disp("");
       return new_c;
     }
 
     Signature red_sig = "red($color)";
     BUILT_IN(red)
-    { return new (ctx.mem) Number(pstate, ARG("$color", Color)->r()); }
+    { return SASS_MEMORY_NEW(ctx.mem, Number, pstate, ARG("$color", Color)->r()); }
 
     Signature green_sig = "green($color)";
     BUILT_IN(green)
-    { return new (ctx.mem) Number(pstate, ARG("$color", Color)->g()); }
+    { return SASS_MEMORY_NEW(ctx.mem, Number, pstate, ARG("$color", Color)->g()); }
 
     Signature blue_sig = "blue($color)";
     BUILT_IN(blue)
-    { return new (ctx.mem) Number(pstate, ARG("$color", Color)->b()); }
+    { return SASS_MEMORY_NEW(ctx.mem, Number, pstate, ARG("$color", Color)->b()); }
 
     Signature mix_sig = "mix($color-1, $color-2, $weight: 50%)";
     BUILT_IN(mix)
@@ -220,11 +309,12 @@ namespace Sass {
       double w1 = (((w * a == -1) ? w : (w + a)/(1 + w*a)) + 1)/2.0;
       double w2 = 1 - w1;
 
-      return new (ctx.mem) Color(pstate,
-                                 std::round(w1*color1->r() + w2*color2->r()),
-                                 std::round(w1*color1->g() + w2*color2->g()),
-                                 std::round(w1*color1->b() + w2*color2->b()),
-                                 color1->a()*p + color2->a()*(1-p));
+      return SASS_MEMORY_NEW(ctx.mem, Color,
+                             pstate,
+                             std::round(w1*color1->r() + w2*color2->r()),
+                             std::round(w1*color1->g() + w2*color2->g()),
+                             std::round(w1*color1->b() + w2*color2->b()),
+                             color1->a()*p + color2->a()*(1-p));
     }
 
     ////////////////
@@ -298,15 +388,15 @@ namespace Sass {
       double g = (h_to_rgb(m1, m2, h) * 255.0);
       double b = (h_to_rgb(m1, m2, h-1.0/3.0) * 255.0);
 
-      return new (ctx.mem) Color(pstate, r, g, b, a);
+      return SASS_MEMORY_NEW(ctx.mem, Color, pstate, r, g, b, a);
     }
 
     Signature hsl_sig = "hsl($hue, $saturation, $lightness)";
     BUILT_IN(hsl)
     {
       return hsla_impl(ARG("$hue", Number)->value(),
-                       ARGR("$saturation", Number, 0, 100)->value(),
-                       ARGR("$lightness", Number, 0, 100)->value(),
+                       ARG("$saturation", Number)->value(),
+                       ARG("$lightness",  Number)->value(),
                        1.0,
                        ctx,
                        pstate);
@@ -316,9 +406,9 @@ namespace Sass {
     BUILT_IN(hsla)
     {
       return hsla_impl(ARG("$hue", Number)->value(),
-                       ARGR("$saturation", Number, 0, 100)->value(),
-                       ARGR("$lightness", Number, 0, 100)->value(),
-                       ARGR("$alpha", Number, 0, 1)->value(),
+                       ARG("$saturation", Number)->value(),
+                       ARG("$lightness",  Number)->value(),
+                       ARG("$alpha",  Number)->value(),
                        ctx,
                        pstate);
     }
@@ -330,7 +420,7 @@ namespace Sass {
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
-      return new (ctx.mem) Number(pstate, hsl_color.h, "deg");
+      return SASS_MEMORY_NEW(ctx.mem, Number, pstate, hsl_color.h, "deg");
     }
 
     Signature saturation_sig = "saturation($color)";
@@ -340,7 +430,7 @@ namespace Sass {
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
-      return new (ctx.mem) Number(pstate, hsl_color.s, "%");
+      return SASS_MEMORY_NEW(ctx.mem, Number, pstate, hsl_color.s, "%");
     }
 
     Signature lightness_sig = "lightness($color)";
@@ -350,7 +440,7 @@ namespace Sass {
       HSL hsl_color = rgb_to_hsl(rgb_color->r(),
                                  rgb_color->g(),
                                  rgb_color->b());
-      return new (ctx.mem) Number(pstate, hsl_color.l, "%");
+      return SASS_MEMORY_NEW(ctx.mem, Number, pstate, hsl_color.l, "%");
     }
 
     Signature adjust_hue_sig = "adjust-hue($color, $degrees)";
@@ -421,7 +511,7 @@ namespace Sass {
       Number* amount = dynamic_cast<Number*>(env["$amount"]);
       if (!amount) {
         To_String to_string(&ctx);
-        return new (ctx.mem) String_Constant(pstate, "saturate(" + env["$color"]->perform(&to_string) + ")");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "saturate(" + env["$color"]->perform(&to_string) + ")");
       }
 
       ARGR("$amount", Number, 0, 100);
@@ -482,7 +572,7 @@ namespace Sass {
       Number* amount = dynamic_cast<Number*>(env["$color"]);
       if (amount) {
         To_String to_string(&ctx);
-        return new (ctx.mem) String_Constant(pstate, "grayscale(" + amount->perform(&to_string) + ")");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "grayscale(" + amount->perform(&to_string) + ")");
       }
 
       Color* rgb_color = ARG("$color", Color);
@@ -519,15 +609,16 @@ namespace Sass {
       Number* amount = dynamic_cast<Number*>(env["$color"]);
       if (amount) {
         To_String to_string(&ctx);
-        return new (ctx.mem) String_Constant(pstate, "invert(" + amount->perform(&to_string) + ")");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "invert(" + amount->perform(&to_string) + ")");
       }
 
       Color* rgb_color = ARG("$color", Color);
-      return new (ctx.mem) Color(pstate,
-                                 255 - rgb_color->r(),
-                                 255 - rgb_color->g(),
-                                 255 - rgb_color->b(),
-                                 rgb_color->a());
+      return SASS_MEMORY_NEW(ctx.mem, Color,
+                             pstate,
+                             255 - rgb_color->r(),
+                             255 - rgb_color->g(),
+                             255 - rgb_color->b(),
+                             rgb_color->a());
     }
 
     ////////////////////
@@ -539,17 +630,17 @@ namespace Sass {
     {
       String_Constant* ie_kwd = dynamic_cast<String_Constant*>(env["$color"]);
       if (ie_kwd) {
-        return new (ctx.mem) String_Constant(pstate, "alpha(" + ie_kwd->value() + ")");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "alpha(" + ie_kwd->value() + ")");
       }
 
       // CSS3 filter function overload: pass literal through directly
       Number* amount = dynamic_cast<Number*>(env["$color"]);
       if (amount) {
         To_String to_string(&ctx);
-        return new (ctx.mem) String_Constant(pstate, "opacity(" + amount->perform(&to_string) + ")");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "opacity(" + amount->perform(&to_string) + ")");
       }
 
-      return new (ctx.mem) Number(pstate, ARG("$color", Color)->a());
+      return SASS_MEMORY_NEW(ctx.mem, Number, pstate, ARG("$color", Color)->a());
     }
 
     Signature opacify_sig = "opacify($color, $amount)";
@@ -559,11 +650,12 @@ namespace Sass {
       Color* color = ARG("$color", Color);
       double amount = ARGR("$amount", Number, 0, 1)->value();
       double alpha = std::min(color->a() + amount, 1.0);
-      return new (ctx.mem) Color(pstate,
-                                 color->r(),
-                                 color->g(),
-                                 color->b(),
-                                 alpha);
+      return SASS_MEMORY_NEW(ctx.mem, Color,
+                             pstate,
+                             color->r(),
+                             color->g(),
+                             color->b(),
+                             alpha);
     }
 
     Signature transparentize_sig = "transparentize($color, $amount)";
@@ -573,11 +665,12 @@ namespace Sass {
       Color* color = ARG("$color", Color);
       double amount = ARGR("$amount", Number, 0, 1)->value();
       double alpha = std::max(color->a() - amount, 0.0);
-      return new (ctx.mem) Color(pstate,
-                                 color->r(),
-                                 color->g(),
-                                 color->b(),
-                                 alpha);
+      return SASS_MEMORY_NEW(ctx.mem, Color,
+                             pstate,
+                             color->r(),
+                             color->g(),
+                             color->b(),
+                             alpha);
     }
 
     ////////////////////////
@@ -603,27 +696,36 @@ namespace Sass {
         error("cannot specify both RGB and HSL values for `adjust-color`", pstate);
       }
       if (rgb) {
-        return new (ctx.mem) Color(pstate,
-                                   color->r() + (r ? r->value() : 0),
-                                   color->g() + (g ? g->value() : 0),
-                                   color->b() + (b ? b->value() : 0),
-                                   color->a() + (a ? a->value() : 0));
+        double rr = r ? ARGR("$red",   Number, -255, 255)->value() : 0;
+        double gg = g ? ARGR("$green", Number, -255, 255)->value() : 0;
+        double bb = b ? ARGR("$blue",  Number, -255, 255)->value() : 0;
+        double aa = a ? ARGR("$alpha", Number, -1, 1)->value() : 0;
+        return SASS_MEMORY_NEW(ctx.mem, Color,
+                               pstate,
+                               color->r() + rr,
+                               color->g() + gg,
+                               color->b() + bb,
+                               color->a() + aa);
       }
       if (hsl) {
         HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());
+        double ss = s ? ARGR("$saturation", Number, -100, 100)->value() : 0;
+        double ll = l ? ARGR("$lightness",  Number, -100, 100)->value() : 0;
+        double aa = a ? ARGR("$alpha",      Number, -1, 1)->value() : 0;
         return hsla_impl(hsl_struct.h + (h ? h->value() : 0),
-                         hsl_struct.s + (s ? s->value() : 0),
-                         hsl_struct.l + (l ? l->value() : 0),
-                         color->a() + (a ? a->value() : 0),
+                         hsl_struct.s + ss,
+                         hsl_struct.l + ll,
+                         color->a() + aa,
                          ctx,
                          pstate);
       }
       if (a) {
-        return new (ctx.mem) Color(pstate,
-                                   color->r(),
-                                   color->g(),
-                                   color->b(),
-                                   color->a() + (a ? a->value() : 0));
+        return SASS_MEMORY_NEW(ctx.mem, Color,
+                               pstate,
+                               color->r(),
+                               color->g(),
+                               color->b(),
+                               color->a() + (a ? a->value() : 0));
       }
       error("not enough arguments for `adjust-color`", pstate);
       // unreachable
@@ -653,11 +755,12 @@ namespace Sass {
         double gscale = (g ? ARGR("$green", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
         double bscale = (b ? ARGR("$blue",  Number, -100.0, 100.0)->value() : 0.0) / 100.0;
         double ascale = (a ? ARGR("$alpha", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
-        return new (ctx.mem) Color(pstate,
-                                   color->r() + rscale * (rscale > 0.0 ? 255 - color->r() : color->r()),
-                                   color->g() + gscale * (gscale > 0.0 ? 255 - color->g() : color->g()),
-                                   color->b() + bscale * (bscale > 0.0 ? 255 - color->b() : color->b()),
-                                   color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));
+        return SASS_MEMORY_NEW(ctx.mem, Color,
+                               pstate,
+                               color->r() + rscale * (rscale > 0.0 ? 255 - color->r() : color->r()),
+                               color->g() + gscale * (gscale > 0.0 ? 255 - color->g() : color->g()),
+                               color->b() + bscale * (bscale > 0.0 ? 255 - color->b() : color->b()),
+                               color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));
       }
       if (hsl) {
         double hscale = (h ? ARGR("$hue",        Number, -100.0, 100.0)->value() : 0.0) / 100.0;
@@ -673,11 +776,12 @@ namespace Sass {
       }
       if (a) {
         double ascale = (a ? ARGR("$alpha", Number, -100.0, 100.0)->value() : 0.0) / 100.0;
-        return new (ctx.mem) Color(pstate,
-                                   color->r(),
-                                   color->g(),
-                                   color->b(),
-                                   color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));
+        return SASS_MEMORY_NEW(ctx.mem, Color,
+                               pstate,
+                               color->r(),
+                               color->g(),
+                               color->b(),
+                               color->a() + ascale * (ascale > 0.0 ? 1.0 - color->a() : color->a()));
       }
       error("not enough arguments for `scale-color`", pstate);
       // unreachable
@@ -703,11 +807,12 @@ namespace Sass {
         error("cannot specify both RGB and HSL values for `change-color`", pstate);
       }
       if (rgb) {
-        return new (ctx.mem) Color(pstate,
-                                   r ? ARGR("$red",   Number, 0, 255)->value() : color->r(),
-                                   g ? ARGR("$green", Number, 0, 255)->value() : color->g(),
-                                   b ? ARGR("$blue",  Number, 0, 255)->value() : color->b(),
-                                   a ? ARGR("$alpha", Number, 0, 255)->value() : color->a());
+        return SASS_MEMORY_NEW(ctx.mem, Color,
+                               pstate,
+                               r ? ARGR("$red",   Number, 0, 255)->value() : color->r(),
+                               g ? ARGR("$green", Number, 0, 255)->value() : color->g(),
+                               b ? ARGR("$blue",  Number, 0, 255)->value() : color->b(),
+                               a ? ARGR("$alpha", Number, 0, 255)->value() : color->a());
       }
       if (hsl) {
         HSL hsl_struct = rgb_to_hsl(color->r(), color->g(), color->b());
@@ -719,11 +824,12 @@ namespace Sass {
       }
       if (a) {
         double alpha = a ? ARGR("$alpha", Number, 0, 1.0)->value() : color->a();
-        return new (ctx.mem) Color(pstate,
-                                   color->r(),
-                                   color->g(),
-                                   color->b(),
-                                   alpha);
+        return SASS_MEMORY_NEW(ctx.mem, Color,
+                               pstate,
+                               color->r(),
+                               color->g(),
+                               color->b(),
+                               alpha);
       }
       error("not enough arguments for `change-color`", pstate);
       // unreachable
@@ -746,18 +852,18 @@ namespace Sass {
       double b = cap_channel<0xff>(c->b());
       double a = cap_channel<1>   (c->a()) * 255;
 
-      stringstream ss;
+      std::stringstream ss;
       ss << '#' << std::setw(2) << std::setfill('0');
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(std::floor(a+0.5));
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(std::floor(r+0.5));
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(std::floor(g+0.5));
       ss << std::hex << std::setw(2) << static_cast<unsigned long>(std::floor(b+0.5));
 
-      string result(ss.str());
+      std::string result(ss.str());
       for (size_t i = 0, L = result.length(); i < L; ++i) {
         result[i] = std::toupper(result[i]);
       }
-      return new (ctx.mem) String_Constant(pstate, result);
+      return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, result);
     }
 
     ///////////////////
@@ -769,16 +875,23 @@ namespace Sass {
     {
       AST_Node* arg = env["$string"];
       if (dynamic_cast<Null*>(arg)) {
-        return new (ctx.mem) Null(pstate);
+        return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
       }
       else if (String_Quoted* string_quoted = dynamic_cast<String_Quoted*>(arg)) {
-        String_Constant* result = new (ctx.mem) String_Constant(pstate, string_quoted->value());
+        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);
         return result;
       }
-      To_String to_string(&ctx);
-      return new (ctx.mem) String_Constant(pstate, unquote(string(arg->perform(&to_string))));
+      else if (dynamic_cast<String_Constant*>(arg)) {
+        return (Expression*) arg;
+      }
+      else {
+        To_String to_string(&ctx);
+        std::string val(arg->perform(&to_string));
+        deprecated("Passing " + val + ", a non-string value, to unquote()", pstate);
+        return (Expression*) arg;
+      }
     }
 
     Signature quote_sig = "quote($string)";
@@ -786,8 +899,8 @@ namespace Sass {
     {
       To_String to_string(&ctx);
       AST_Node* arg = env["$string"];
-      string str(quote(arg->perform(&to_string), String_Constant::double_quote()));
-      String_Constant* result = new (ctx.mem) String_Constant(pstate, str);
+      std::string str(quote(arg->perform(&to_string), String_Constant::double_quote()));
+      String_Quoted* result = SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
       result->is_delayed(true);
       return result;
     }
@@ -796,39 +909,29 @@ namespace Sass {
     Signature str_length_sig = "str-length($string)";
     BUILT_IN(str_length)
     {
-      size_t len = string::npos;
+      size_t len = std::string::npos;
       try {
         String_Constant* s = ARG("$string", String_Constant);
         len = UTF_8::code_point_count(s->value(), 0, s->value().size());
 
       }
-      catch (utf8::invalid_code_point) {
-        string msg("utf8::invalid_code_point");
-        error(msg, pstate, backtrace);
-      }
-      catch (utf8::not_enough_room) {
-        string msg("utf8::not_enough_room");
-        error(msg, pstate, backtrace);
-      }
-      catch (utf8::invalid_utf8) {
-        string msg("utf8::invalid_utf8");
-        error(msg, pstate, backtrace);
-      }
-      catch (...) { throw; }
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, backtrace); }
       // return something even if we had an error (-1)
-      return new (ctx.mem) Number(pstate, len);
+      return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)len);
     }
 
     Signature str_insert_sig = "str-insert($string, $insert, $index)";
     BUILT_IN(str_insert)
     {
-      string str;
+      std::string str;
       try {
         String_Constant* s = ARG("$string", String_Constant);
         str = s->value();
         str = unquote(str);
         String_Constant* i = ARG("$insert", String_Constant);
-        string ins = i->value();
+        std::string ins = i->value();
         ins = unquote(ins);
         Number* ind = ARG("$index", Number);
         double index = ind->value();
@@ -859,108 +962,78 @@ namespace Sass {
           if (ss->quote_mark()) str = quote(str);
         }
       }
-      catch (utf8::invalid_code_point) {
-        string msg("utf8::invalid_code_point");
-        error(msg, pstate, backtrace);
-      }
-      catch (utf8::not_enough_room) {
-        string msg("utf8::not_enough_room");
-        error(msg, pstate, backtrace);
-      }
-      catch (utf8::invalid_utf8) {
-        string msg("utf8::invalid_utf8");
-        error(msg, pstate, backtrace);
-      }
-      catch (...) { throw; }
-      return new (ctx.mem) String_Constant(pstate, str);
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, backtrace); }
+      return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
     }
 
     Signature str_index_sig = "str-index($string, $substring)";
     BUILT_IN(str_index)
     {
-      size_t index = string::npos;
+      size_t index = std::string::npos;
       try {
         String_Constant* s = ARG("$string", String_Constant);
         String_Constant* t = ARG("$substring", String_Constant);
-        string str = s->value();
+        std::string str = s->value();
         str = unquote(str);
-        string substr = t->value();
+        std::string substr = t->value();
         substr = unquote(substr);
 
         size_t c_index = str.find(substr);
-        if(c_index == string::npos) {
-          return new (ctx.mem) Null(pstate);
+        if(c_index == std::string::npos) {
+          return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
         }
         index = UTF_8::code_point_count(str, 0, c_index) + 1;
       }
-      catch (utf8::invalid_code_point) {
-        string msg("utf8::invalid_code_point");
-        error(msg, pstate, backtrace);
-      }
-      catch (utf8::not_enough_room) {
-        string msg("utf8::not_enough_room");
-        error(msg, pstate, backtrace);
-      }
-      catch (utf8::invalid_utf8) {
-        string msg("utf8::invalid_utf8");
-        error(msg, pstate, backtrace);
-      }
-      catch (...) { throw; }
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, backtrace); }
       // return something even if we had an error (-1)
-      return new (ctx.mem) Number(pstate, index);
+      return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)index);
     }
 
     Signature str_slice_sig = "str-slice($string, $start-at, $end-at:-1)";
     BUILT_IN(str_slice)
     {
-      string newstr;
+      std::string newstr;
       try {
         String_Constant* s = ARG("$string", String_Constant);
         double start_at = ARG("$start-at", Number)->value();
         double end_at = ARG("$end-at", Number)->value();
 
-        string str = unquote(s->value());
+        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) { end_at = size; }
+        if (end_at > size) { end_at = (double)size; }
         if (start_at < 0) { start_at += size + 1; }
         else if (start_at == 0) { ++ start_at; }
 
         if (start_at <= end_at)
         {
-          string::iterator start = str.begin();
+          std::string::iterator start = str.begin();
           utf8::advance(start, start_at - 1, str.end());
-          string::iterator end = start;
+          std::string::iterator end = start;
           utf8::advance(end, end_at - start_at + 1, str.end());
-          newstr = string(start, end);
+          newstr = std::string(start, end);
         }
         if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
           if(ss->quote_mark()) newstr = quote(newstr);
         }
       }
-      catch (utf8::invalid_code_point) {
-        string msg("utf8::invalid_code_point");
-        error(msg, pstate, backtrace);
-      }
-      catch (utf8::not_enough_room) {
-        string msg("utf8::not_enough_room");
-        error(msg, pstate, backtrace);
-      }
-      catch (utf8::invalid_utf8) {
-        string msg("utf8::invalid_utf8");
-        error(msg, pstate, backtrace);
-      }
-      catch (...) { throw; }
-      return new (ctx.mem) String_Quoted(pstate, newstr);
+      // handle any invalid utf8 errors
+      // other errors will be re-thrown
+      catch (...) { handle_utf8_error(pstate, backtrace); }
+      return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, newstr);
     }
 
     Signature to_upper_case_sig = "to-upper-case($string)";
     BUILT_IN(to_upper_case)
     {
       String_Constant* s = ARG("$string", String_Constant);
-      string str = s->value();
+      std::string str = s->value();
 
       for (size_t i = 0, L = str.length(); i < L; ++i) {
         if (Sass::Util::isAscii(str[i])) {
@@ -969,16 +1042,19 @@ namespace Sass {
       }
 
       if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
-        str = ss->quote_mark() ? quote(str) : str;
+        String_Quoted* cpy = SASS_MEMORY_NEW(ctx.mem, String_Quoted, *ss);
+        cpy->value(str);
+        return cpy;
+      } else {
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
       }
-      return new (ctx.mem) String_Constant(pstate, str);
     }
 
     Signature to_lower_case_sig = "to-lower-case($string)";
     BUILT_IN(to_lower_case)
     {
       String_Constant* s = ARG("$string", String_Constant);
-      string str = s->value();
+      std::string str = s->value();
 
       for (size_t i = 0, L = str.length(); i < L; ++i) {
         if (Sass::Util::isAscii(str[i])) {
@@ -987,9 +1063,12 @@ namespace Sass {
       }
 
       if (String_Quoted* ss = dynamic_cast<String_Quoted*>(s)) {
-        str = ss->quote_mark() ? quote(str, '"') : str;
+        String_Quoted* cpy = SASS_MEMORY_NEW(ctx.mem, String_Quoted, *ss);
+        cpy->value(str);
+        return cpy;
+      } else {
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, str);
       }
-      return new (ctx.mem) String_Constant(pstate, str);
     }
 
     ///////////////////
@@ -1000,15 +1079,15 @@ namespace Sass {
     BUILT_IN(percentage)
     {
       Number* n = ARG("$number", Number);
-      if (!n->is_unitless()) error("argument $number of `" + string(sig) + "` must be unitless", pstate);
-      return new (ctx.mem) Number(pstate, n->value() * 100, "%");
+      if (!n->is_unitless()) error("argument $number of `" + std::string(sig) + "` must be unitless", pstate);
+      return SASS_MEMORY_NEW(ctx.mem, Number, pstate, n->value() * 100, "%");
     }
 
     Signature round_sig = "round($number)";
     BUILT_IN(round)
     {
       Number* n = ARG("$number", Number);
-      Number* r = new (ctx.mem) Number(*n);
+      Number* r = SASS_MEMORY_NEW(ctx.mem, Number, *n);
       r->pstate(pstate);
       r->value(std::floor(r->value() + 0.5));
       return r;
@@ -1018,7 +1097,7 @@ namespace Sass {
     BUILT_IN(ceil)
     {
       Number* n = ARG("$number", Number);
-      Number* r = new (ctx.mem) Number(*n);
+      Number* r = SASS_MEMORY_NEW(ctx.mem, Number, *n);
       r->pstate(pstate);
       r->value(std::ceil(r->value()));
       return r;
@@ -1028,7 +1107,7 @@ namespace Sass {
     BUILT_IN(floor)
     {
       Number* n = ARG("$number", Number);
-      Number* r = new (ctx.mem) Number(*n);
+      Number* r = SASS_MEMORY_NEW(ctx.mem, Number, *n);
       r->pstate(pstate);
       r->value(std::floor(r->value()));
       return r;
@@ -1038,7 +1117,7 @@ namespace Sass {
     BUILT_IN(abs)
     {
       Number* n = ARG("$number", Number);
-      Number* r = new (ctx.mem) Number(*n);
+      Number* r = SASS_MEMORY_NEW(ctx.mem, Number, *n);
       r->pstate(pstate);
       r->value(std::abs(r->value()));
       return r;
@@ -1051,9 +1130,9 @@ namespace Sass {
       Number* least = 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Number* xi = dynamic_cast<Number*>(arglist->value_at_index(i));
-        if (!xi) error("`" + string(sig) + "` only takes numeric arguments", pstate);
+        if (!xi) error("`" + std::string(sig) + "` only takes numeric arguments", pstate);
         if (least) {
-          if (lt(xi, least, ctx)) least = xi;
+          if (Eval::lt(xi, least)) least = xi;
         } else least = xi;
       }
       return least;
@@ -1066,9 +1145,9 @@ namespace Sass {
       Number* greatest = 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Number* xi = dynamic_cast<Number*>(arglist->value_at_index(i));
-        if (!xi) error("`" + string(sig) + "` only takes numeric arguments", pstate);
+        if (!xi) error("`" + std::string(sig) + "` only takes numeric arguments", pstate);
         if (greatest) {
-          if (lt(greatest, xi, ctx)) greatest = xi;
+          if (Eval::lt(greatest, xi)) greatest = xi;
         } else greatest = xi;
       }
       return greatest;
@@ -1079,15 +1158,26 @@ namespace Sass {
     {
       Number* l = dynamic_cast<Number*>(env["$limit"]);
       if (l) {
-        if (trunc(l->value()) != l->value() || l->value() == 0) error("argument $limit of `" + string(sig) + "` must be a positive integer", pstate);
-        uniform_real_distribution<> distributor(1, l->value() + 1);
+        double v = l->value();
+        if (v < 1) {
+          stringstream err;
+          err << "$limit " << v << " must be greater than or equal to 1 for `random`";
+          error(err.str(), pstate);
+        }
+        bool eq_int = std::fabs(trunc(v) - v) < NUMBER_EPSILON;
+        if (!eq_int) {
+          stringstream err;
+          err << "Expected $limit to be an integer but got `" << v << "` for `random`";
+          error(err.str(), pstate);
+        }
+        std::uniform_real_distribution<> distributor(1, v + 1);
         uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
-        return new (ctx.mem) Number(pstate, (double)distributed);
+        return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)distributed);
       }
       else {
-        uniform_real_distribution<> distributor(0, 1);
+        std::uniform_real_distribution<> distributor(0, 1);
         double distributed = static_cast<double>(distributor(rand));
-        return new (ctx.mem) Number(pstate, distributed);
+        return SASS_MEMORY_NEW(ctx.mem, Number, pstate, distributed);
      }
     }
 
@@ -1101,13 +1191,24 @@ namespace Sass {
       Expression* v = ARG("$list", Expression);
       if (v->concrete_type() == Expression::MAP) {
         Map* map = dynamic_cast<Map*>(env["$list"]);
-        return new (ctx.mem) Number(pstate,
-                                    map ? map->length() : 1);
+        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)) {
+          return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)h->length());
+        } else if (Selector_List* ls = dynamic_cast<Selector_List*>(v)) {
+          return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)ls->length());
+        } else {
+          return SASS_MEMORY_NEW(ctx.mem, Number, pstate, 1);
+        }
       }
 
       List* list = dynamic_cast<List*>(env["$list"]);
-      return new (ctx.mem) Number(pstate,
-                                  list ? list->size() : 1);
+      return SASS_MEMORY_NEW(ctx.mem, Number,
+                             pstate,
+                             (double)(list ? list->size() : 1));
     }
 
     Signature nth_sig = "nth($list, $n)";
@@ -1116,20 +1217,20 @@ namespace Sass {
       Map* m = dynamic_cast<Map*>(env["$list"]);
       List* l = dynamic_cast<List*>(env["$list"]);
       Number* n = ARG("$n", Number);
-      if (n->value() == 0) error("argument `$n` of `" + string(sig) + "` must be non-zero", pstate);
+      if (n->value() == 0) error("argument `$n` of `" + std::string(sig) + "` must be non-zero", pstate);
       // if the argument isn't a list, then wrap it in a singleton list
       if (!m && !l) {
-        l = new (ctx.mem) List(pstate, 1);
+        l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l << ARG("$list", Expression);
       }
       size_t len = m ? m->length() : l->length();
       bool empty = m ? m->empty() : l->empty();
-      if (empty) error("argument `$list` of `" + string(sig) + "` must not be empty", pstate);
+      if (empty) error("argument `$list` of `" + std::string(sig) + "` must not be empty", pstate);
       double index = std::floor(n->value() < 0 ? len + n->value() : n->value() - 1);
-      if (index < 0 || index > len - 1) error("index out of bounds for `" + string(sig) + "`", pstate);
+      if (index < 0 || index > len - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
 
       if (m) {
-        l = new (ctx.mem) List(pstate, 1);
+        l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l << m->keys()[static_cast<unsigned int>(index)];
         *l << m->at(m->keys()[static_cast<unsigned int>(index)]);
         return l;
@@ -1146,13 +1247,13 @@ namespace Sass {
       Number* n = ARG("$n", Number);
       Expression* v = ARG("$value", Expression);
       if (!l) {
-        l = new (ctx.mem) List(pstate, 1);
+        l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l << ARG("$list", Expression);
       }
-      if (l->empty()) error("argument `$list` of `" + string(sig) + "` must not be empty", 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 `" + string(sig) + "`", pstate);
-      List* result = new (ctx.mem) List(pstate, l->length(), l->separator());
+      if (index < 0 || index > l->length() - 1) error("index out of bounds for `" + std::string(sig) + "`", pstate);
+      List* result = SASS_MEMORY_NEW(ctx.mem, List, pstate, l->length(), l->separator());
       for (size_t i = 0, L = l->length(); i < L; ++i) {
         *result << ((i == index) ? v : (*l)[i]);
       }
@@ -1165,13 +1266,13 @@ namespace Sass {
       List* l = dynamic_cast<List*>(env["$list"]);
       Expression* v = ARG("$value", Expression);
       if (!l) {
-        l = new (ctx.mem) List(pstate, 1);
+        l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l << ARG("$list", Expression);
       }
       for (size_t i = 0, L = l->length(); i < L; ++i) {
-        if (eq(l->value_at_index(i), v, ctx)) return new (ctx.mem) Number(pstate, i+1);
+        if (Eval::eq(l->value_at_index(i), v)) return SASS_MEMORY_NEW(ctx.mem, Number, pstate, (double)(i+1));
       }
-      return new (ctx.mem) Null(pstate);
+      return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
     }
 
     Signature join_sig = "join($list1, $list2, $separator: auto)";
@@ -1180,22 +1281,22 @@ namespace Sass {
       List* l1 = dynamic_cast<List*>(env["$list1"]);
       List* l2 = dynamic_cast<List*>(env["$list2"]);
       String_Constant* sep = ARG("$separator", String_Constant);
-      List::Separator sep_val = (l1 ? l1->separator() : List::SPACE);
+      enum Sass_Separator sep_val = (l1 ? l1->separator() : SASS_SPACE);
       if (!l1) {
-        l1 = new (ctx.mem) List(pstate, 1);
+        l1 = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l1 << ARG("$list1", Expression);
-        sep_val = (l2 ? l2->separator() : List::SPACE);
+        sep_val = (l2 ? l2->separator() : SASS_SPACE);
       }
       if (!l2) {
-        l2 = new (ctx.mem) List(pstate, 1);
+        l2 = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l2 << ARG("$list2", Expression);
       }
       size_t len = l1->length() + l2->length();
-      string sep_str = unquote(sep->value());
-      if (sep_str == "space") sep_val = List::SPACE;
-      else if (sep_str == "comma") sep_val = List::COMMA;
-      else if (sep_str != "auto") error("argument `$separator` of `" + string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
-      List* result = new (ctx.mem) List(pstate, len, sep_val);
+      std::string sep_str = unquote(sep->value());
+      if (sep_str == "space") sep_val = SASS_SPACE;
+      else if (sep_str == "comma") sep_val = SASS_COMMA;
+      else if (sep_str != "auto") error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
+      List* result = SASS_MEMORY_NEW(ctx.mem, List, pstate, len, sep_val);
       *result += l1;
       *result += l2;
       return result;
@@ -1208,23 +1309,24 @@ namespace Sass {
       Expression* v = ARG("$val", Expression);
       String_Constant* sep = ARG("$separator", String_Constant);
       if (!l) {
-        l = new (ctx.mem) List(pstate, 1);
+        l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l << ARG("$list", Expression);
       }
-      List* result = new (ctx.mem) List(pstate, l->length() + 1, l->separator());
-      string sep_str(unquote(sep->value()));
-      if (sep_str == "space") result->separator(List::SPACE);
-      else if (sep_str == "comma") result->separator(List::COMMA);
-      else if (sep_str != "auto") error("argument `$separator` of `" + string(sig) + "` must be `space`, `comma`, or `auto`", 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);
+      else if (sep_str == "comma") result->separator(SASS_COMMA);
+      else if (sep_str != "auto") error("argument `$separator` of `" + std::string(sig) + "` must be `space`, `comma`, or `auto`", pstate);
       *result += l;
       bool is_arglist = l->is_arglist();
       result->is_arglist(is_arglist);
       if (is_arglist) {
-        *result << new (ctx.mem) Argument(v->pstate(),
-                                          v,
-                                          "",
-                                          false,
-                                          false);
+        *result << SASS_MEMORY_NEW(ctx.mem, Argument,
+                                   v->pstate(),
+                                   v,
+                                   "",
+                                   false,
+                                   false);
 
       } else {
         *result << v;
@@ -1235,12 +1337,12 @@ namespace Sass {
     Signature zip_sig = "zip($lists...)";
     BUILT_IN(zip)
     {
-      List* arglist = new (ctx.mem) List(*ARG("$lists", List));
+      List* arglist = SASS_MEMORY_NEW(ctx.mem, List, *ARG("$lists", List));
       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));
         if (!ith) {
-          ith = new (ctx.mem) List(pstate, 1);
+          ith = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
           *ith << arglist->value_at_index(i);
           if (arglist->is_arglist()) {
             ((Argument*)(*arglist)[i])->value(ith);
@@ -1250,10 +1352,10 @@ namespace Sass {
         }
         shortest = (i ? std::min(shortest, ith->length()) : ith->length());
       }
-      List* zippers = new (ctx.mem) List(pstate, shortest, List::COMMA);
+      List* zippers = SASS_MEMORY_NEW(ctx.mem, List, pstate, shortest, SASS_COMMA);
       size_t L = arglist->length();
       for (size_t i = 0; i < shortest; ++i) {
-        List* zipper = new (ctx.mem) List(pstate, L);
+        List* zipper = SASS_MEMORY_NEW(ctx.mem, List, pstate, L);
         for (size_t j = 0; j < L; ++j) {
           *zipper << (*static_cast<List*>(arglist->value_at_index(j)))[i];
         }
@@ -1267,11 +1369,12 @@ namespace Sass {
     {
       List* l = dynamic_cast<List*>(env["$list"]);
       if (!l) {
-        l = new (ctx.mem) List(pstate, 1);
+        l = SASS_MEMORY_NEW(ctx.mem, List, pstate, 1);
         *l << ARG("$list", Expression);
       }
-      return new (ctx.mem) String_Constant(pstate,
-                                           l->separator() == List::COMMA ? "comma" : "space");
+      return SASS_MEMORY_NEW(ctx.mem, String_Quoted,
+                               pstate,
+                               l->separator() == SASS_COMMA ? "comma" : "space");
     }
 
     /////////////////
@@ -1286,7 +1389,7 @@ namespace Sass {
       try {
         return m->at(v);
       } catch (const std::out_of_range&) {
-        return new (ctx.mem) Null(pstate);
+        return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
       }
       catch (...) { throw; }
     }
@@ -1296,14 +1399,14 @@ namespace Sass {
     {
       Map* m = ARGM("$map", Map, ctx);
       Expression* v = ARG("$key", Expression);
-      return new (ctx.mem) Boolean(pstate, m->has(v));
+      return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, m->has(v));
     }
 
     Signature map_keys_sig = "map-keys($map)";
     BUILT_IN(map_keys)
     {
       Map* m = ARGM("$map", Map, ctx);
-      List* result = new (ctx.mem) List(pstate, m->length(), List::COMMA);
+      List* result = SASS_MEMORY_NEW(ctx.mem, List, pstate, m->length(), SASS_COMMA);
       for ( auto key : m->keys()) {
         *result << key;
       }
@@ -1314,7 +1417,7 @@ namespace Sass {
     BUILT_IN(map_values)
     {
       Map* m = ARGM("$map", Map, ctx);
-      List* result = new (ctx.mem) List(pstate, m->length(), List::COMMA);
+      List* result = SASS_MEMORY_NEW(ctx.mem, List, pstate, m->length(), SASS_COMMA);
       for ( auto key : m->keys()) {
         *result << m->at(key);
       }
@@ -1328,7 +1431,7 @@ namespace Sass {
       Map* m2 = ARGM("$map2", Map, ctx);
 
       size_t len = m1->length() + m2->length();
-      Map* result = new (ctx.mem) Map(pstate, len);
+      Map* result = SASS_MEMORY_NEW(ctx.mem, Map, pstate, len);
       *result += m1;
       *result += m2;
       return result;
@@ -1340,13 +1443,13 @@ namespace Sass {
       bool remove;
       Map* m = ARGM("$map", Map, ctx);
       List* arglist = ARG("$keys", List);
-      Map* result = new (ctx.mem) Map(pstate, 1);
+      Map* result = SASS_MEMORY_NEW(ctx.mem, Map, pstate, 1);
       for (auto key : m->keys()) {
         remove = false;
         for (size_t j = 0, K = arglist->length(); j < K && !remove; ++j) {
-          remove = eq(key, arglist->value_at_index(j), ctx);
+          remove = Eval::eq(key, arglist->value_at_index(j));
         }
-        if (!remove) *result << make_pair(key, m->at(key));
+        if (!remove) *result << std::make_pair(key, m->at(key));
       }
       return result;
     }
@@ -1354,13 +1457,14 @@ namespace Sass {
     Signature keywords_sig = "keywords($args)";
     BUILT_IN(keywords)
     {
-      List* arglist = new (ctx.mem) List(*ARG("$args", List));
-      Map* result = new (ctx.mem) Map(pstate, 1);
+      List* arglist = SASS_MEMORY_NEW(ctx.mem, List, *ARG("$args", List));
+      Map* result = SASS_MEMORY_NEW(ctx.mem, Map, pstate, 1);
       for (size_t i = arglist->size(), L = arglist->length(); i < L; ++i) {
-        string name = string(((Argument*)(*arglist)[i])->name());
+        std::string name = std::string(((Argument*)(*arglist)[i])->name());
         name = name.erase(0, 1); // sanitize name (remove dollar sign)
-        *result << make_pair(new (ctx.mem) String_Constant(pstate, name),
-                             ((Argument*)(*arglist)[i])->value());
+        *result << std::make_pair(SASS_MEMORY_NEW(ctx.mem, String_Quoted,
+                 pstate, name),
+                 ((Argument*)(*arglist)[i])->value());
       }
       return result;
     }
@@ -1373,23 +1477,16 @@ namespace Sass {
     BUILT_IN(type_of)
     {
       Expression* v = ARG("$value", Expression);
-      if (v->concrete_type() == Expression::STRING) {
-        To_String to_string(&ctx);
-        string str(v->perform(&to_string));
-        if (ctx.names_to_colors.count(str)) {
-          return new (ctx.mem) String_Constant(pstate, "color");
-        }
-      }
-      return new (ctx.mem) String_Constant(pstate, ARG("$value", Expression)->type());
+      return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, v->type());
     }
 
     Signature unit_sig = "unit($number)";
     BUILT_IN(unit)
-    { return new (ctx.mem) String_Quoted(pstate, quote(ARG("$number", Number)->unit(), '"')); }
+    { return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, quote(ARG("$number", Number)->unit(), '"')); }
 
     Signature unitless_sig = "unitless($number)";
     BUILT_IN(unitless)
-    { return new (ctx.mem) Boolean(pstate, ARG("$number", Number)->is_unitless()); }
+    { return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, ARG("$number", Number)->is_unitless()); }
 
     Signature comparable_sig = "comparable($number-1, $number-2)";
     BUILT_IN(comparable)
@@ -1397,103 +1494,111 @@ namespace Sass {
       Number* n1 = ARG("$number-1", Number);
       Number* n2 = ARG("$number-2", Number);
       if (n1->is_unitless() || n2->is_unitless()) {
-        return new (ctx.mem) Boolean(pstate, true);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
       }
       Number tmp_n2(*n2);
       tmp_n2.normalize(n1->find_convertible_unit());
-      return new (ctx.mem) Boolean(pstate, n1->unit() == tmp_n2.unit());
+      return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, n1->unit() == tmp_n2.unit());
     }
 
     Signature variable_exists_sig = "variable-exists($name)";
     BUILT_IN(variable_exists)
     {
-      string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has("$"+s)) {
-        return new (ctx.mem) Boolean(pstate, true);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
       }
       else {
-        return new (ctx.mem) Boolean(pstate, false);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, false);
       }
     }
 
     Signature global_variable_exists_sig = "global-variable-exists($name)";
     BUILT_IN(global_variable_exists)
     {
-      string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has_global("$"+s)) {
-        return new (ctx.mem) Boolean(pstate, true);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
       }
       else {
-        return new (ctx.mem) Boolean(pstate, false);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, false);
       }
     }
 
     Signature function_exists_sig = "function-exists($name)";
     BUILT_IN(function_exists)
     {
-      string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has_global(s+"[f]")) {
-        return new (ctx.mem) Boolean(pstate, true);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
       }
       else {
-        return new (ctx.mem) Boolean(pstate, false);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, false);
       }
     }
 
     Signature mixin_exists_sig = "mixin-exists($name)";
     BUILT_IN(mixin_exists)
     {
-      string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      std::string s = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
 
       if(d_env.has_global(s+"[m]")) {
-        return new (ctx.mem) Boolean(pstate, true);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
       }
       else {
-        return new (ctx.mem) Boolean(pstate, false);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, false);
       }
     }
 
     Signature feature_exists_sig = "feature-exists($name)";
     BUILT_IN(feature_exists)
     {
-      string s = unquote(ARG("$name", String_Constant)->value());
+      std::string s = unquote(ARG("$name", String_Constant)->value());
 
       if(features.find(s) == features.end()) {
-        return new (ctx.mem) Boolean(pstate, false);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, false);
       }
       else {
-        return new (ctx.mem) Boolean(pstate, true);
+        return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, true);
       }
     }
 
     Signature call_sig = "call($name, $args...)";
     BUILT_IN(call)
     {
-      string name = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
-      List* arglist = new (ctx.mem) List(*ARG("$args", List));
+      std::string name = Util::normalize_underscores(unquote(ARG("$name", String_Constant)->value()));
+      List* arglist = SASS_MEMORY_NEW(ctx.mem, List, *ARG("$args", List));
 
-      Arguments* args = new (ctx.mem) Arguments(pstate);
+      Arguments* args = SASS_MEMORY_NEW(ctx.mem, Arguments, pstate);
+      std::string full_name(name + "[f]");
+      Definition* def = d_env.has(full_name) ? static_cast<Definition*>((d_env)[full_name]) : 0;
+      Parameters* params = def ? def->parameters() : 0;
+      size_t param_size = params ? params->length() : 0;
       for (size_t i = 0, L = arglist->length(); i < L; ++i) {
         Expression* expr = arglist->value_at_index(i);
+        if (params && params->has_rest_parameter()) {
+          Parameter* p = param_size > i ? (*params)[i] : 0;
+          List* list = dynamic_cast<List*>(expr);
+          if (list && p && !p->is_rest_parameter()) expr = (*list)[0];
+        }
         if (arglist->is_arglist()) {
-          Argument* arg = static_cast<Argument*>((*arglist)[i]);
-          *args << new (ctx.mem) Argument(pstate,
-                                          expr,
-                                          "",
-                                          arg->is_rest_argument(),
-                                          arg->is_keyword_argument());
+          Argument* arg = dynamic_cast<Argument*>((*arglist)[i]);
+          *args << SASS_MEMORY_NEW(ctx.mem, Argument,
+                                   pstate,
+                                   expr,
+                                   arg ? arg->name() : "",
+                                   arg ? arg->is_rest_argument() : false,
+                                   arg ? arg->is_keyword_argument() : false);
         } else {
-          *args << new (ctx.mem) Argument(pstate, expr);
+          *args << SASS_MEMORY_NEW(ctx.mem, Argument, pstate, expr);
         }
       }
-      Function_Call* func = new (ctx.mem) Function_Call(pstate, name, args);
-      Contextualize contextualize(ctx, &d_env, backtrace);
-      Listize listize(ctx);
-      Eval eval(ctx, &contextualize, &listize, &d_env, backtrace);
-      return func->perform(&eval);
+      Function_Call* func = SASS_MEMORY_NEW(ctx.mem, Function_Call, pstate, name, args);
+      Expand expand(ctx, &d_env, backtrace);
+      return func->perform(&expand.eval);
 
     }
 
@@ -1503,22 +1608,20 @@ namespace Sass {
 
     Signature not_sig = "not($value)";
     BUILT_IN(sass_not)
-    { return new (ctx.mem) Boolean(pstate, ARG("$value", Expression)->is_false()); }
+    { return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, ARG("$value", Expression)->is_false()); }
 
     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)
     {
-      Contextualize contextualize(ctx, &d_env, backtrace);
-      Listize listize(ctx);
-      Eval eval(ctx, &contextualize, &listize, &d_env, backtrace);
-      bool is_true = !ARG("$condition", Expression)->perform(&eval)->is_false();
+      Expand expand(ctx, &d_env, backtrace);
+      bool is_true = !ARG("$condition", Expression)->perform(&expand.eval)->is_false();
       if (is_true) {
-        return ARG("$if-true", Expression)->perform(&eval);
+        return ARG("$if-true", Expression)->perform(&expand.eval);
       }
       else {
-        return ARG("$if-false", Expression)->perform(&eval);
+        return ARG("$if-false", Expression)->perform(&expand.eval);
       }
     }
 
@@ -1542,9 +1645,9 @@ namespace Sass {
     {
       Expression* v = ARG("$value", Expression);
       if (v->concrete_type() == Expression::NULL_VAL) {
-        return new (ctx.mem) String_Constant(pstate, "null");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "null");
       } else if (v->concrete_type() == Expression::BOOLEAN && *v == 0) {
-        return new (ctx.mem) String_Constant(pstate, "false");
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, "false");
       } else if (v->concrete_type() == Expression::STRING) {
         return v;
       } else {
@@ -1554,38 +1657,244 @@ namespace Sass {
         old_style = ctx.output_style;
         ctx.output_style = NESTED;
         To_String to_string(&ctx, false);
-        string inspect = v->perform(&to_string);
+        std::string inspect = v->perform(&to_string);
         if (inspect.empty() && parentheses) inspect = "()";
         ctx.output_style = old_style;
-        return new (ctx.mem) String_Constant(pstate, inspect);
+        return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, inspect);
+      }
+      // return v;
+    }
+    Signature selector_nest_sig = "selector-nest($selectors...)";
+    BUILT_IN(selector_nest)
+    {
+      To_String to_string(&ctx, false);
+      List* arglist = ARG("$selectors", List);
+
+      // Not enough parameters
+      if( arglist->length() == 0 )
+        error("$selectors: At least one selector must be passed", pstate);
 
+      // Parse args into vector of selectors
+      std::vector<Selector_List*> 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) {
+          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);
+        }
+        std::string exp_src = exp->perform(&to_string) + "{";
+        Selector_List* sel = Parser::parse_selector(exp_src.c_str(), ctx);
+        parsedSelectors.push_back(sel);
+      }
 
+      // Nothing to do
+      if( parsedSelectors.empty() ) {
+        return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
       }
-      // return v;
+
+      // 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;
+      ++itr;
+
+      for(;itr != parsedSelectors.end(); ++itr) {
+        Selector_List* child = *itr;
+        std::vector<Complex_Selector*> exploded;
+        Selector_List* rv = child->parentize(result, ctx);
+        for (size_t m = 0, mLen = rv->length(); m < mLen; ++m) {
+          exploded.push_back((*rv)[m]);
+        }
+        result->elements(exploded);
+      }
+
+      Listize listize(ctx);
+      return result->perform(&listize);
+    }
+
+    Signature selector_append_sig = "selector-append($selectors...)";
+    BUILT_IN(selector_append)
+    {
+      To_String to_string;
+      List* arglist = ARG("$selectors", List);
+
+      // Not enough parameters
+      if( arglist->length() == 0 )
+        error("$selectors: At least one selector must be passed", pstate);
+
+      // Parse args into vector of selectors
+      std::vector<Selector_List*> 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) {
+          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);
+        }
+        std::string exp_src = exp->perform(&to_string) + "{";
+        Selector_List* sel = Parser::parse_selector(exp_src.c_str(), ctx);
+        parsedSelectors.push_back(sel);
+      }
+
+      // Nothing to do
+      if( parsedSelectors.empty() ) {
+        return SASS_MEMORY_NEW(ctx.mem, Null, pstate);
+      }
+
+      // 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;
+      ++itr;
+
+      for(;itr != parsedSelectors.end(); ++itr) {
+        Selector_List* child = *itr;
+        std::vector<Complex_Selector*> 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* parentSeqClone = (*result)[i]->cloneFully(ctx);
+            Complex_Selector* childSeq = (*child)[j];
+            Complex_Selector* base = childSeq->tail();
+
+            // Must be a simple sequence
+            if( childSeq->combinator() != Complex_Selector::Combinator::ANCESTOR_OF ) {
+              std::string msg("Can't append  `");
+              msg += childSeq->perform(&to_string);
+              msg += "` to `";
+              msg += parentSeqClone->perform(&to_string);;
+              msg += "`";
+              error(msg, pstate, backtrace);
+            }
+
+            // Cannot be a Universal selector
+            Type_Selector* pType = dynamic_cast<Type_Selector*>(base->head()->first());
+            if(pType && pType->name() == "*") {
+              std::string msg("Can't append  `");
+              msg += childSeq->perform(&to_string);
+              msg += "` to `";
+              msg += parentSeqClone->perform(&to_string);;
+              msg += "`";
+              error(msg, pstate, backtrace);
+            }
+
+            // TODO: Add check for namespace stuff
+
+            // append any selectors in childSeq's head
+            *(parentSeqClone->innermost()->head()) += (base->head());
+
+            // Set parentSeqClone new tail
+            parentSeqClone->innermost()->tail( base->tail() );
+
+            newElements.push_back(parentSeqClone);
+          }
+        }
+
+        result->elements(newElements);
+      }
+
+      Listize listize(ctx);
+      return result->perform(&listize);
+    }
+
+    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);
+
+      Selector_List* result = selector1->unify_with(selector2, ctx);
+      Listize listize(ctx);
+      return result->perform(&listize);
+    }
+
+    Signature simple_selectors_sig = "simple-selectors($selector)";
+    BUILT_IN(simple_selectors)
+    {
+      Compound_Selector* sel = ARGSEL("$selector", Compound_Selector, p_contextualize);
+
+      To_String to_string;
+      List* l = SASS_MEMORY_NEW(ctx.mem, List, sel->pstate(), sel->length(), SASS_COMMA);
+
+      for (size_t i = 0, L = sel->length(); i < L; ++i) {
+        Simple_Selector* ss = (*sel)[i];
+        std::string ss_string = ss->perform(&to_string) ;
+
+        *l << SASS_MEMORY_NEW(ctx.mem, String_Quoted, ss->pstate(), ss_string);
+      }
+
+      return l;
+    }
+
+    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);
+
+      ExtensionSubsetMap subset_map;
+      extender->populate_extends(extendee, ctx, subset_map);
+
+      bool extendedSomething;
+      Selector_List* result = Extend::extendSelectorList(selector, ctx, subset_map, false, extendedSomething);
+
+      Listize listize(ctx);
+      return result->perform(&listize);
+    }
+
+    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);
+
+      ExtensionSubsetMap subset_map;
+      replacement->populate_extends(original, ctx, subset_map);
+
+      bool extendedSomething;
+      Selector_List* result = Extend::extendSelectorList(selector, ctx, subset_map, true, extendedSomething);
+
+      Listize listize(ctx);
+      return result->perform(&listize);
+    }
+
+    Signature selector_parse_sig = "selector-parse($selector)";
+    BUILT_IN(selector_parse)
+    {
+      Selector_List* sel = ARGSEL("$selector", Selector_List, p_contextualize);
+
+      Listize listize(ctx);
+      return sel->perform(&listize);
     }
 
     Signature is_superselector_sig = "is-superselector($super, $sub)";
     BUILT_IN(is_superselector)
     {
       To_String to_string(&ctx, false);
-      Expression*  ex_sup = ARG("$super", Expression);
-      Expression*  ex_sub = ARG("$sub", Expression);
-      string sup_src = ex_sup->perform(&to_string) + "{";
-      string sub_src = ex_sub->perform(&to_string) + "{";
-      Selector_List* sel_sup = Parser::parse_selector(sup_src.c_str(), ctx);
-      Selector_List* sel_sub = Parser::parse_selector(sub_src.c_str(), ctx);
+      Selector_List*  sel_sup = ARGSEL("$super", Selector_List, p_contextualize);
+      Selector_List*  sel_sub = ARGSEL("$sub", Selector_List, p_contextualize);
       bool result = sel_sup->is_superselector_of(sel_sub);
-      return new (ctx.mem) Boolean(pstate, result);
+      return SASS_MEMORY_NEW(ctx.mem, Boolean, pstate, result);
     }
 
     Signature unique_id_sig = "unique-id()";
     BUILT_IN(unique_id)
     {
       std::stringstream ss;
-      uniform_real_distribution<> distributor(0, 4294967296); // 16^8
+      std::uniform_real_distribution<> distributor(0, 4294967296); // 16^8
       uint_fast32_t distributed = static_cast<uint_fast32_t>(distributor(rand));
-      ss << "u" << setfill('0') << setw(8) << std::hex << distributed;
-      return new (ctx.mem) String_Constant(pstate, ss.str());
+      ss << "u" << std::setfill('0') << std::setw(8) << std::hex << distributed;
+      return SASS_MEMORY_NEW(ctx.mem, String_Quoted, pstate, ss.str());
     }
 
   }