sassc 2.0.1 → 2.1.0.pre1

data/ext/libsass/src/operators.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "operators.hpp"
 
 namespace Sass {
@@ -54,13 +57,24 @@ namespace Sass {
     bool lte(Expression_Obj lhs, Expression_Obj rhs) { return cmp(lhs, rhs, Sass_OP::LTE) || eq(lhs, rhs); }
     bool gte(Expression_Obj lhs, Expression_Obj rhs) { return !cmp(lhs, rhs, Sass_OP::GTE) || eq(lhs, rhs); }
 
+    /* colour math deprecation warning */
+    void op_color_deprecation(enum Sass_OP op, std::string lsh, std::string rhs, const ParserState& pstate)
+    {
+      deprecated(
+        "The operation `" + lsh + " " + sass_op_to_name(op) + " " + rhs +
+        "` is deprecated and will be an error in future versions.",
+        "Consider using Sass's color functions instead.\n"
+        "https://sass-lang.com/documentation/Sass/Script/Functions.html#other_color_functions",
+        /*with_column=*/false, pstate);
+    }
+
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value_Ptr op_strings(Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_strings(Sass::Operand operand, Value& lhs, Value& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
     {
       enum Sass_OP op = operand.operand;
 
-      String_Quoted_Ptr lqstr = Cast<String_Quoted>(&lhs);
-      String_Quoted_Ptr rqstr = Cast<String_Quoted>(&rhs);
+      String_Quoted* lqstr = Cast<String_Quoted>(&lhs);
+      String_Quoted* rqstr = Cast<String_Quoted>(&rhs);
 
       std::string lstr(lqstr ? lqstr->value() : lhs.to_string(opt));
       std::string rstr(rqstr ? rqstr->value() : rhs.to_string(opt));
@@ -104,16 +118,21 @@ namespace Sass {
       return SASS_MEMORY_NEW(String_Constant, pstate, lstr + sep + rstr);
     }
 
+    /* ToDo: allow to operate also with hsla colors */
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value_Ptr op_colors(enum Sass_OP op, const Color& lhs, const Color& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_colors(enum Sass_OP op, const Color_RGBA& lhs, const Color_RGBA& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
     {
+
       if (lhs.a() != rhs.a()) {
         throw Exception::AlphaChannelsNotEqual(&lhs, &rhs, op);
       }
-      if (op == Sass_OP::DIV && (!rhs.r() || !rhs.g() || !rhs.b())) {
+      if ((op == Sass_OP::DIV || op == Sass_OP::MOD) && (!rhs.r() || !rhs.g() || !rhs.b())) {
         throw Exception::ZeroDivisionError(lhs, rhs);
       }
-      return SASS_MEMORY_NEW(Color,
+
+      op_color_deprecation(op, lhs.to_string(), rhs.to_string(), pstate);
+
+      return SASS_MEMORY_NEW(Color_RGBA,
                              pstate,
                              ops[op](lhs.r(), rhs.r()),
                              ops[op](lhs.g(), rhs.g()),
@@ -122,20 +141,20 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value_Ptr op_numbers(enum Sass_OP op, const Number& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_numbers(enum Sass_OP op, const Number& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
     {
       double lval = lhs.value();
       double rval = rhs.value();
 
+      if (op == Sass_OP::MOD && rval == 0) {
+        return SASS_MEMORY_NEW(String_Quoted, pstate, "NaN");
+      }
+
       if (op == Sass_OP::DIV && rval == 0) {
         std::string result(lval ? "Infinity" : "NaN");
         return SASS_MEMORY_NEW(String_Quoted, pstate, result);
       }
 
-      if (op == Sass_OP::MOD && rval == 0) {
-        throw Exception::ZeroDivisionError(lhs, rhs);
-      }
-
       size_t l_n_units = lhs.numerators.size();
       size_t l_d_units = lhs.numerators.size();
       size_t r_n_units = rhs.denominators.size();
@@ -145,7 +164,7 @@ namespace Sass {
         if (l_n_units + l_d_units <= 1 && r_n_units + r_d_units <= 1) {
           if (lhs.numerators == rhs.numerators) {
             if (lhs.denominators == rhs.denominators) {
-              Number_Ptr v = SASS_MEMORY_COPY(&lhs);
+              Number* v = SASS_MEMORY_COPY(&lhs);
               v->value(ops[op](lval, rval));
               return v;
             }
@@ -192,13 +211,15 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value_Ptr op_number_color(enum Sass_OP op, const Number& lhs, const Color& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_number_color(enum Sass_OP op, const Number& lhs, const Color_RGBA& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
     {
       double lval = lhs.value();
+
       switch (op) {
         case Sass_OP::ADD:
         case Sass_OP::MUL: {
-          return SASS_MEMORY_NEW(Color,
+          op_color_deprecation(op, lhs.to_string(), rhs.to_string(opt), pstate);
+          return SASS_MEMORY_NEW(Color_RGBA,
                                 pstate,
                                 ops[op](lval, rhs.r()),
                                 ops[op](lval, rhs.g()),
@@ -208,6 +229,7 @@ namespace Sass {
         case Sass_OP::SUB:
         case Sass_OP::DIV: {
           std::string color(rhs.to_string(opt));
+          op_color_deprecation(op, lhs.to_string(), color, pstate);
           return SASS_MEMORY_NEW(String_Quoted,
                                 pstate,
                                 lhs.to_string(opt)
@@ -220,14 +242,18 @@ namespace Sass {
     }
 
     /* static function, throws OperationError, has no traces but optional pstate for returned value */
-    Value_Ptr op_color_number(enum Sass_OP op, const Color& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
+    Value* op_color_number(enum Sass_OP op, const Color_RGBA& lhs, const Number& rhs, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed)
     {
       double rval = rhs.value();
-      if (op == Sass_OP::DIV && rval == 0) {
+
+      if ((op == Sass_OP::DIV || op == Sass_OP::DIV) && rval == 0) {
         // comparison of Fixnum with Float failed?
         throw Exception::ZeroDivisionError(lhs, rhs);
       }
-      return SASS_MEMORY_NEW(Color,
+
+      op_color_deprecation(op, lhs.to_string(), rhs.to_string(), pstate);
+
+      return SASS_MEMORY_NEW(Color_RGBA,
                             pstate,
                             ops[op](lhs.r(), rval),
                             ops[op](lhs.g(), rval),

data/ext/libsass/src/operators.hpp

@@ -17,11 +17,11 @@ namespace Sass {
     bool lte(Expression_Obj, Expression_Obj);
     bool gte(Expression_Obj, Expression_Obj);
     // arithmetic for all the combinations that matter
-    Value_Ptr op_strings(Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value_Ptr op_colors(enum Sass_OP, const Color&, const Color&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value_Ptr op_numbers(enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value_Ptr op_number_color(enum Sass_OP, const Number&, const Color&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
-    Value_Ptr op_color_number(enum Sass_OP, const Color&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_strings(Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_colors(enum Sass_OP, const Color_RGBA&, const Color_RGBA&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_numbers(enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_number_color(enum Sass_OP, const Number&, const Color_RGBA&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
+    Value* op_color_number(enum Sass_OP, const Color_RGBA&, const Number&, struct Sass_Inspect_Options opt, const ParserState& pstate, bool delayed = false);
 
   };
 

data/ext/libsass/src/output.cpp

@@ -1,6 +1,10 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "ast.hpp"
 #include "output.hpp"
+#include "util.hpp"
 
 namespace Sass {
 
@@ -12,12 +16,12 @@ namespace Sass {
 
   Output::~Output() { }
 
-  void Output::fallback_impl(AST_Node_Ptr n)
+  void Output::fallback_impl(AST_Node* n)
   {
     return n->perform(this);
   }
 
-  void Output::operator()(Number_Ptr n)
+  void Output::operator()(Number* n)
   {
     // check for a valid unit here
     // includes result for reporting
@@ -31,12 +35,12 @@ namespace Sass {
     append_token(res, n);
   }
 
-  void Output::operator()(Import_Ptr imp)
+  void Output::operator()(Import* imp)
   {
     top_nodes.push_back(imp);
   }
 
-  void Output::operator()(Map_Ptr m)
+  void Output::operator()(Map* m)
   {
     // should be handle in check_expression
     throw Exception::InvalidValue({}, *m);
@@ -86,9 +90,8 @@ namespace Sass {
 
   }
 
-  void Output::operator()(Comment_Ptr c)
+  void Output::operator()(Comment* c)
   {
-    std::string txt = c->text()->to_string(opt);
     // if (indentation && txt == "/**/") return;
     bool important = c->is_important();
     if (output_style() != COMPRESSED || important) {
@@ -108,7 +111,7 @@ namespace Sass {
     }
   }
 
-  void Output::operator()(Ruleset_Ptr r)
+  void Output::operator()(Ruleset* r)
   {
     Selector_Obj s     = r->selector();
     Block_Obj    b     = r->block();
@@ -142,19 +145,19 @@ namespace Sass {
       Statement_Obj stm = b->at(i);
       bool bPrintExpression = true;
       // Check print conditions
-      if (Declaration_Ptr dec = Cast<Declaration>(stm)) {
-        if (String_Constant_Ptr valConst = Cast<String_Constant>(dec->value())) {
+      if (Declaration* dec = Cast<Declaration>(stm)) {
+        if (String_Constant* valConst = Cast<String_Constant>(dec->value())) {
           std::string val(valConst->value());
-          if (String_Quoted_Ptr qstr = Cast<String_Quoted>(valConst)) {
+          if (String_Quoted* qstr = Cast<String_Quoted>(valConst)) {
             if (!qstr->quote_mark() && val.empty()) {
               bPrintExpression = false;
             }
           }
         }
-        else if (List_Ptr list = Cast<List>(dec->value())) {
+        else if (List* list = Cast<List>(dec->value())) {
           bool all_invisible = true;
           for (size_t list_i = 0, list_L = list->length(); list_i < list_L; ++list_i) {
-            Expression_Ptr item = list->at(list_i);
+            Expression* item = list->at(list_i);
             if (!item->is_invisible()) all_invisible = false;
           }
           if (all_invisible && !list->is_bracketed()) bPrintExpression = false;
@@ -169,7 +172,7 @@ namespace Sass {
     append_scope_closer(b);
 
   }
-  void Output::operator()(Keyframe_Rule_Ptr r)
+  void Output::operator()(Keyframe_Rule* r)
   {
     Block_Obj b = r->block();
     Selector_Obj v = r->name();
@@ -192,7 +195,7 @@ namespace Sass {
     append_scope_closer();
   }
 
-  void Output::operator()(Supports_Block_Ptr f)
+  void Output::operator()(Supports_Block* f)
   {
     if (f->is_invisible()) return;
 
@@ -229,7 +232,7 @@ namespace Sass {
 
   }
 
-  void Output::operator()(Media_Block_Ptr m)
+  void Output::operator()(Media_Block* m)
   {
     if (m->is_invisible()) return;
 
@@ -266,7 +269,7 @@ namespace Sass {
     append_scope_closer();
   }
 
-  void Output::operator()(Directive_Ptr a)
+  void Output::operator()(Directive* a)
   {
     std::string      kwd   = a->keyword();
     Selector_Obj   s     = a->selector();
@@ -309,7 +312,7 @@ namespace Sass {
     append_scope_closer();
   }
 
-  void Output::operator()(String_Quoted_Ptr s)
+  void Output::operator()(String_Quoted* s)
   {
     if (s->quote_mark()) {
       append_token(quote(s->value(), s->quote_mark()), s);
@@ -320,7 +323,7 @@ namespace Sass {
     }
   }
 
-  void Output::operator()(String_Constant_Ptr s)
+  void Output::operator()(String_Constant* s)
   {
     std::string value(s->value());
     if (s->can_compress_whitespace() && output_style() == COMPRESSED) {

data/ext/libsass/src/output.hpp

@@ -11,13 +11,6 @@
 namespace Sass {
   class Context;
 
-  // Refactor to make it generic to find linefeed (look behind)
-  inline bool ends_with(std::string const & value, std::string const & ending)
-  {
-    if (ending.size() > value.size()) return false;
-    return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
-  }
-
   class Output : public Inspect {
   protected:
     using Inspect::operator();
@@ -28,24 +21,24 @@ namespace Sass {
 
   protected:
     std::string charset;
-    std::vector<AST_Node_Ptr> top_nodes;
+    std::vector<AST_Node*> top_nodes;
 
   public:
     OutputBuffer get_buffer(void);
 
-    virtual void operator()(Map_Ptr);
-    virtual void operator()(Ruleset_Ptr);
-    virtual void operator()(Supports_Block_Ptr);
-    virtual void operator()(Media_Block_Ptr);
-    virtual void operator()(Directive_Ptr);
-    virtual void operator()(Keyframe_Rule_Ptr);
-    virtual void operator()(Import_Ptr);
-    virtual void operator()(Comment_Ptr);
-    virtual void operator()(Number_Ptr);
-    virtual void operator()(String_Quoted_Ptr);
-    virtual void operator()(String_Constant_Ptr);
-
-    void fallback_impl(AST_Node_Ptr n);
+    virtual void operator()(Map*);
+    virtual void operator()(Ruleset*);
+    virtual void operator()(Supports_Block*);
+    virtual void operator()(Media_Block*);
+    virtual void operator()(Directive*);
+    virtual void operator()(Keyframe_Rule*);
+    virtual void operator()(Import*);
+    virtual void operator()(Comment*);
+    virtual void operator()(Number*);
+    virtual void operator()(String_Quoted*);
+    virtual void operator()(String_Constant*);
+
+    void fallback_impl(AST_Node* n);
 
   };
 

data/ext/libsass/src/parser.cpp

@@ -1,4 +1,7 @@
+// sass.hpp must go before all system headers to get the
+// __EXTENSIONS__ fix on Solaris.
 #include "sass.hpp"
+
 #include "parser.hpp"
 #include "file.hpp"
 #include "inspect.hpp"
@@ -8,6 +11,7 @@
 #include "color_maps.hpp"
 #include "sass/functions.h"
 #include "error_handling.hpp"
+#include "util_string.hpp"
 
 // Notes about delayed: some ast nodes can have delayed evaluation so
 // they can preserve their original semantics if needed. This is most
@@ -30,11 +34,11 @@ namespace Sass {
   using namespace Constants;
   using namespace Prelexer;
 
-  Parser Parser::from_c_str(const char* beg, Context& ctx, Backtraces traces, ParserState pstate, const char* source)
+  Parser Parser::from_c_str(const char* beg, Context& ctx, Backtraces traces, ParserState pstate, const char* source, bool allow_parent)
   {
     pstate.offset.column = 0;
     pstate.offset.line = 0;
-    Parser p(ctx, pstate, traces);
+    Parser p(ctx, pstate, traces, allow_parent);
     p.source   = source ? source : beg;
     p.position = beg ? beg : p.source;
     p.end      = p.position + strlen(p.position);
@@ -44,11 +48,11 @@ namespace Sass {
     return p;
   }
 
-  Parser Parser::from_c_str(const char* beg, const char* end, Context& ctx, Backtraces traces, ParserState pstate, const char* source)
+  Parser Parser::from_c_str(const char* beg, const char* end, Context& ctx, Backtraces traces, ParserState pstate, const char* source, bool allow_parent)
   {
     pstate.offset.column = 0;
     pstate.offset.line = 0;
-    Parser p(ctx, pstate, traces);
+    Parser p(ctx, pstate, traces, allow_parent);
     p.source   = source ? source : beg;
     p.position = beg ? beg : p.source;
     p.end      = end ? end : p.position + strlen(p.position);
@@ -66,10 +70,9 @@ namespace Sass {
       pstate.offset.line = 0;
     }
 
-  Selector_List_Obj Parser::parse_selector(const char* beg, Context& ctx, Backtraces traces, ParserState pstate, const char* source)
+  Selector_List_Obj Parser::parse_selector(const char* beg, Context& ctx, Backtraces traces, ParserState pstate, const char* source, bool allow_parent)
   {
-    Parser p = Parser::from_c_str(beg, ctx, traces, pstate, source);
-    // ToDo: ruby sass errors on parent references
+    Parser p = Parser::from_c_str(beg, ctx, traces, pstate, source, allow_parent);
     // ToDo: remap the source-map entries somehow
     return p.parse_selector_list(false);
   }
@@ -333,11 +336,11 @@ namespace Sass {
     do {
       while (lex< block_comment >());
       if (lex< quoted_string >()) {
-        to_import.push_back(std::pair<std::string,Function_Call_Obj>(std::string(lexed), 0));
+        to_import.push_back(std::pair<std::string,Function_Call_Obj>(std::string(lexed), {}));
       }
       else if (lex< uri_prefix >()) {
         Arguments_Obj args = SASS_MEMORY_NEW(Arguments, pstate);
-        Function_Call_Obj result = SASS_MEMORY_NEW(Function_Call, pstate, "url", args);
+        Function_Call_Obj result = SASS_MEMORY_NEW(Function_Call, pstate, std::string("url"), args);
 
         if (lex< quoted_string >()) {
           Expression_Obj quoted_url = parse_string();
@@ -479,7 +482,7 @@ namespace Sass {
       bool is_arglist = false;
       bool is_keyword = false;
       Expression_Obj val = parse_space_list();
-      List_Ptr l = Cast<List>(val);
+      List* l = Cast<List>(val);
       if (lex_css< exactly< ellipsis > >()) {
         if (val->concrete_type() == Expression::MAP || (
            (l != NULL && l->separator() == SASS_HASH)
@@ -556,7 +559,7 @@ namespace Sass {
     lex< optional_spaces >();
     const char* i = position;
     // selector schema re-uses string schema implementation
-    String_Schema_Ptr schema = SASS_MEMORY_NEW(String_Schema, pstate);
+    String_Schema* schema = SASS_MEMORY_NEW(String_Schema, pstate);
     // the selector schema is pretty much just a wrapper for the string schema
     Selector_Schema_Obj selector_schema = SASS_MEMORY_NEW(Selector_Schema, pstate, schema);
     selector_schema->connect_parent(chroot == false);
@@ -645,13 +648,27 @@ namespace Sass {
     // normalize underscores to hyphens
     std::string name(Util::normalize_underscores(lexed));
     // create the initial mixin call object
-    Mixin_Call_Obj call = SASS_MEMORY_NEW(Mixin_Call, pstate, name, 0, 0);
+    Mixin_Call_Obj call = SASS_MEMORY_NEW(Mixin_Call, pstate, name, {}, {}, {});
     // parse mandatory arguments
     call->arguments(parse_arguments());
+    // parse using and optional block parameters
+    bool has_parameters = lex< kwd_using >() != nullptr;
+
+    if (has_parameters) {
+      if (!peek< exactly<'('> >()) css_error("Invalid CSS", " after ", ": expected \"(\", was ");
+    } else {
+      if (peek< exactly<'('> >()) css_error("Invalid CSS", " after ", ": expected \";\", was ");
+    }
+
+    if (has_parameters) call->block_parameters(parse_parameters());
+
     // parse optional block
     if (peek < exactly <'{'> >()) {
       call->block(parse_block());
     }
+    else if (has_parameters)  {
+      css_error("Invalid CSS", " after ", ": expected \"{\", was ");
+    }
     // return ast node
     return call.detach();
   }
@@ -706,7 +723,7 @@ namespace Sass {
     }
     // update for end position
     group->update_pstate(pstate);
-    if (sel) sel->last()->has_line_break(false);
+    if (sel) sel->mutable_last()->has_line_break(false);
     return group.detach();
   }
   // EO parse_selector_list
@@ -719,12 +736,12 @@ namespace Sass {
   {
 
     NESTING_GUARD(nestings);
-    String_Obj reference = 0;
+    String_Obj reference;
     lex < block_comment >();
     advanceToNextToken();
     Complex_Selector_Obj sel = SASS_MEMORY_NEW(Complex_Selector, pstate);
 
-    if (peek < end_of_file >()) return 0;
+    if (peek < end_of_file >()) return {};
 
     // parse the left hand side
     Compound_Selector_Obj lhs;
@@ -743,12 +760,12 @@ namespace Sass {
     else if (lex< sequence < exactly<'/'>, negate < exactly < '*' > > > >()) {
       // comments are allowed, but not spaces?
       combinator = Complex_Selector::REFERENCE;
-      if (!lex < re_reference_combinator >()) return 0;
+      if (!lex < re_reference_combinator >()) return {};
       reference = SASS_MEMORY_NEW(String_Constant, pstate, lexed);
-      if (!lex < exactly < '/' > >()) return 0; // ToDo: error msg?
+      if (!lex < exactly < '/' > >()) return {}; // ToDo: error msg?
     }
 
-    if (!lhs && combinator == Complex_Selector::ANCESTOR_OF) return 0;
+    if (!lhs && combinator == Complex_Selector::ANCESTOR_OF) return {};
 
     // lex < block_comment >();
     sel->head(lhs);
@@ -771,7 +788,7 @@ namespace Sass {
     if (!sel->has_parent_ref() && !chroot) {
       // create the objects to wrap parent selector reference
       Compound_Selector_Obj head = SASS_MEMORY_NEW(Compound_Selector, pstate);
-      Parent_Selector_Ptr parent = SASS_MEMORY_NEW(Parent_Selector, pstate, false);
+      Parent_Selector* parent = SASS_MEMORY_NEW(Parent_Selector, pstate, false);
       parent->media_block(last_media_block);
       head->media_block(last_media_block);
       // add simple selector
@@ -818,6 +835,7 @@ namespace Sass {
       // parse parent selector
       else if (lex< exactly<'&'> >(false))
       {
+        if (!allow_parent) error("Parent selectors aren't allowed here.");
         // this produces a linefeed!?
         seq->has_parent_reference(true);
         seq->append(SASS_MEMORY_NEW(Parent_Selector, pstate));
@@ -837,7 +855,7 @@ namespace Sass {
       // parse type selector
       else if (lex< re_type_selector >(false))
       {
-        seq->append(SASS_MEMORY_NEW(Element_Selector, pstate, lexed));
+        seq->append(SASS_MEMORY_NEW(Type_Selector, pstate, lexed));
       }
       // peek for abort conditions
       else if (peek< spaces >()) break;
@@ -847,7 +865,7 @@ namespace Sass {
       // otherwise parse another simple selector
       else {
         Simple_Selector_Obj sel = parse_simple_selector();
-        if (!sel) return 0;
+        if (!sel) return {};
         seq->append(sel);
       }
     }
@@ -872,7 +890,7 @@ namespace Sass {
       return SASS_MEMORY_NEW(Id_Selector, pstate, lexed);
     }
     else if (lex< alternatives < variable, number, static_reference_combinator > >()) {
-      return SASS_MEMORY_NEW(Element_Selector, pstate, lexed);
+      return SASS_MEMORY_NEW(Type_Selector, pstate, lexed);
     }
     else if (peek< pseudo_not >()) {
       return parse_negated_selector();
@@ -887,7 +905,7 @@ namespace Sass {
       return parse_attribute_selector();
     }
     else if (lex< placeholder >()) {
-      Placeholder_Selector_Ptr sel = SASS_MEMORY_NEW(Placeholder_Selector, pstate, lexed);
+      Placeholder_Selector* sel = SASS_MEMORY_NEW(Placeholder_Selector, pstate, lexed);
       sel->media_block(last_media_block);
       return sel;
     }
@@ -895,7 +913,7 @@ namespace Sass {
       css_error("Invalid CSS", " after ", ": expected selector, was ");
     }
     // failed
-    return 0;
+    return {};
   }
 
   Wrapped_Selector_Obj Parser::parse_negated_selector()
@@ -915,7 +933,7 @@ namespace Sass {
   // it can contain more selectors inside parentheses
   Simple_Selector_Obj Parser::parse_pseudo_selector() {
     if (lex< sequence<
-          optional < pseudo_prefix >,
+          pseudo_prefix,
           // we keep the space within the name, strange enough
           // ToDo: refactor output to schedule the space for it
           // or do we really want to keep the real white-space?
@@ -966,7 +984,7 @@ namespace Sass {
     css_error("Invalid CSS", " after ", ": expected \")\", was ");
 
     // unreachable statement
-    return 0;
+    return {};
   }
 
   const char* Parser::re_attr_sensitive_close(const char* src)
@@ -985,11 +1003,11 @@ namespace Sass {
     if (!lex_css< attribute_name >()) error("invalid attribute name in attribute selector");
     std::string name(lexed);
     if (lex_css< re_attr_sensitive_close >()) {
-      return SASS_MEMORY_NEW(Attribute_Selector, p, name, "", 0, 0);
+      return SASS_MEMORY_NEW(Attribute_Selector, p, name, "", {}, {});
     }
     else if (lex_css< re_attr_insensitive_close >()) {
       char modifier = lexed.begin[0];
-      return SASS_MEMORY_NEW(Attribute_Selector, p, name, "", 0, modifier);
+      return SASS_MEMORY_NEW(Attribute_Selector, p, name, "", {}, modifier);
     }
     if (!lex_css< alternatives< exact_match, class_match, dash_match,
                                 prefix_match, suffix_match, substring_match > >()) {
@@ -997,7 +1015,7 @@ namespace Sass {
     }
     std::string matcher(lexed);
 
-    String_Obj value = 0;
+    String_Obj value;
     if (lex_css< identifier >()) {
       value = SASS_MEMORY_NEW(String_Constant, p, lexed);
     }
@@ -1016,7 +1034,7 @@ namespace Sass {
       return SASS_MEMORY_NEW(Attribute_Selector, p, name, matcher, value, modifier);
     }
     error("unterminated attribute selector for " + name);
-    return NULL; // to satisfy compilers (error must not return)
+    return {}; // to satisfy compilers (error must not return)
   }
 
   /* parse block comment and add to block */
@@ -1072,7 +1090,7 @@ namespace Sass {
       }
       else {
         value = parse_list(DELAYED);
-        if (List_Ptr list = Cast<List>(value)) {
+        if (List* list = Cast<List>(value)) {
           if (!list->is_bracketed() && list->length() == 0 && !peek< exactly <'{'> >()) {
             css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
           }
@@ -1478,7 +1496,7 @@ namespace Sass {
     }
     else if (lex< identifier_schema >()) {
       String_Obj string = parse_identifier_schema();
-      if (String_Schema_Ptr schema = Cast<String_Schema>(string)) {
+      if (String_Schema* schema = Cast<String_Schema>(string)) {
         if (lex < exactly < '(' > >()) {
           schema->append(parse_list());
           lex < exactly < ')' > >();
@@ -1493,29 +1511,29 @@ namespace Sass {
       return parse_function_call();
     }
     else if (lex< exactly<'+'> >()) {
-      Unary_Expression_Ptr ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::PLUS, parse_factor());
+      Unary_Expression* ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::PLUS, parse_factor());
       if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());
       return ex;
     }
     else if (lex< exactly<'-'> >()) {
-      Unary_Expression_Ptr ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::MINUS, parse_factor());
+      Unary_Expression* ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::MINUS, parse_factor());
       if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());
       return ex;
     }
     else if (lex< exactly<'/'> >()) {
-      Unary_Expression_Ptr ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::SLASH, parse_factor());
+      Unary_Expression* ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::SLASH, parse_factor());
       if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());
       return ex;
     }
     else if (lex< sequence< kwd_not > >()) {
-      Unary_Expression_Ptr ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::NOT, parse_factor());
+      Unary_Expression* ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::NOT, parse_factor());
       if (ex && ex->operand()) ex->is_delayed(ex->operand()->is_delayed());
       return ex;
     }
     // this whole branch is never hit via spec tests
     else if (peek < sequence < one_plus < alternatives < css_whitespace, exactly<'-'>, exactly<'+'> > >, number > >()) {
       if (parse_number_prefix()) return parse_value(); // prefix is positive
-      Unary_Expression_Ptr ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::MINUS, parse_value());
+      Unary_Expression* ex = SASS_MEMORY_NEW(Unary_Expression, pstate, Unary_Expression::MINUS, parse_value());
       if (ex->operand()) ex->is_delayed(ex->operand()->is_delayed());
       return ex;
     }
@@ -1533,9 +1551,9 @@ namespace Sass {
               (L > 2 && parsed.substr(0, 3) == "-0.") );
   }
 
-  Number_Ptr Parser::lexed_number(const ParserState& pstate, const std::string& parsed)
+  Number* Parser::lexed_number(const ParserState& pstate, const std::string& parsed)
   {
-    Number_Ptr nr = SASS_MEMORY_NEW(Number,
+    Number* nr = SASS_MEMORY_NEW(Number,
                                     pstate,
                                     sass_strtod(parsed.c_str()),
                                     "",
@@ -1545,9 +1563,9 @@ namespace Sass {
     return nr;
   }
 
-  Number_Ptr Parser::lexed_percentage(const ParserState& pstate, const std::string& parsed)
+  Number* Parser::lexed_percentage(const ParserState& pstate, const std::string& parsed)
   {
-    Number_Ptr nr = SASS_MEMORY_NEW(Number,
+    Number* nr = SASS_MEMORY_NEW(Number,
                                     pstate,
                                     sass_strtod(parsed.c_str()),
                                     "%",
@@ -1557,7 +1575,7 @@ namespace Sass {
     return nr;
   }
 
-  Number_Ptr Parser::lexed_dimension(const ParserState& pstate, const std::string& parsed)
+  Number* Parser::lexed_dimension(const ParserState& pstate, const std::string& parsed)
   {
     size_t L = parsed.length();
     size_t num_pos = parsed.find_first_not_of(" \n\r\t");
@@ -1568,7 +1586,7 @@ namespace Sass {
     }
     if (unit_pos == std::string::npos) unit_pos = L;
     const std::string& num = parsed.substr(num_pos, unit_pos - num_pos);
-    Number_Ptr nr = SASS_MEMORY_NEW(Number,
+    Number* nr = SASS_MEMORY_NEW(Number,
                                     pstate,
                                     sass_strtod(num.c_str()),
                                     Token(number(parsed.c_str())),
@@ -1578,9 +1596,9 @@ namespace Sass {
     return nr;
   }
 
-  Expression_Ptr Parser::lexed_hex_color(const ParserState& pstate, const std::string& parsed)
+  Value* Parser::lexed_hex_color(const ParserState& pstate, const std::string& parsed)
   {
-    Color_Ptr color = NULL;
+    Color_RGBA* color = NULL;
     if (parsed[0] != '#') {
       return SASS_MEMORY_NEW(String_Quoted, pstate, parsed);
     }
@@ -1590,7 +1608,7 @@ namespace Sass {
       std::string r(2, parsed[1]);
       std::string g(2, parsed[2]);
       std::string b(2, parsed[3]);
-      color = SASS_MEMORY_NEW(Color,
+      color = SASS_MEMORY_NEW(Color_RGBA,
                                pstate,
                                static_cast<double>(strtol(r.c_str(), NULL, 16)),
                                static_cast<double>(strtol(g.c_str(), NULL, 16)),
@@ -1598,11 +1616,24 @@ namespace Sass {
                                1, // alpha channel
                                parsed);
     }
+    else if (parsed.length() == 5) {
+      std::string r(2, parsed[1]);
+      std::string g(2, parsed[2]);
+      std::string b(2, parsed[3]);
+      std::string a(2, parsed[4]);
+      color = SASS_MEMORY_NEW(Color_RGBA,
+                               pstate,
+                               static_cast<double>(strtol(r.c_str(), NULL, 16)),
+                               static_cast<double>(strtol(g.c_str(), NULL, 16)),
+                               static_cast<double>(strtol(b.c_str(), NULL, 16)),
+                               static_cast<double>(strtol(a.c_str(), NULL, 16)) / 255,
+                               parsed);
+    }
     else if (parsed.length() == 7) {
       std::string r(parsed.substr(1,2));
       std::string g(parsed.substr(3,2));
       std::string b(parsed.substr(5,2));
-      color = SASS_MEMORY_NEW(Color,
+      color = SASS_MEMORY_NEW(Color_RGBA,
                                pstate,
                                static_cast<double>(strtol(r.c_str(), NULL, 16)),
                                static_cast<double>(strtol(g.c_str(), NULL, 16)),
@@ -1615,7 +1646,7 @@ namespace Sass {
       std::string g(parsed.substr(3,2));
       std::string b(parsed.substr(5,2));
       std::string a(parsed.substr(7,2));
-      color = SASS_MEMORY_NEW(Color,
+      color = SASS_MEMORY_NEW(Color_RGBA,
                                pstate,
                                static_cast<double>(strtol(r.c_str(), NULL, 16)),
                                static_cast<double>(strtol(g.c_str(), NULL, 16)),
@@ -1628,6 +1659,19 @@ namespace Sass {
     return color;
   }
 
+  Value* Parser::color_or_string(const std::string& lexed) const
+  {
+    if (auto color = name_to_color(lexed)) {
+      auto c = SASS_MEMORY_NEW(Color_RGBA, color);
+      c->is_delayed(true);
+      c->pstate(pstate);
+      c->disp(lexed);
+      return c;
+    } else {
+      return SASS_MEMORY_NEW(String_Constant, pstate, lexed);
+    }
+  }
+
   // parse one value for a list
   Expression_Obj Parser::parse_value()
   {
@@ -1637,7 +1681,7 @@ namespace Sass {
       if (match< ampersand >()) {
         warning("In Sass, \"&&\" means two copies of the parent selector. You probably want to use \"and\" instead.", pstate);
       }
-      return SASS_MEMORY_NEW(Parent_Selector, pstate); }
+      return SASS_MEMORY_NEW(Parent_Reference, pstate); }
 
     if (lex< kwd_important >())
     { return SASS_MEMORY_NEW(String_Constant, pstate, "!important"); }
@@ -1670,7 +1714,7 @@ namespace Sass {
     { return SASS_MEMORY_NEW(Null, pstate); }
 
     if (lex< identifier >()) {
-      return SASS_MEMORY_NEW(String_Constant, pstate, lexed);
+      return color_or_string(lexed);
     }
 
     if (lex< percentage >())
@@ -1681,17 +1725,7 @@ namespace Sass {
     { return lexed_hex_color(lexed); }
 
     if (lex< hexa >())
-    {
-      std::string s = lexed.to_string();
-
-      deprecated(
-        "The value \""+s+"\" is currently parsed as a string, but it will be parsed as a color in",
-        "future versions of Sass. Use \"unquote('"+s+"')\" to continue parsing it as a string.",
-        true, pstate
-      );
-
-      return SASS_MEMORY_NEW(String_Quoted, pstate, lexed);
-    }
+    { return lexed_hex_color(lexed); }
 
     if (lex< sequence < exactly <'#'>, identifier > >())
     { return SASS_MEMORY_NEW(String_Quoted, pstate, lexed); }
@@ -1710,14 +1744,10 @@ namespace Sass {
     if (lex< variable >())
     { return SASS_MEMORY_NEW(Variable, pstate, Util::normalize_underscores(lexed)); }
 
-    // Special case handling for `%` proceeding an interpolant.
-    if (lex< sequence< exactly<'%'>, optional< percentage > > >())
-    { return SASS_MEMORY_NEW(String_Constant, pstate, lexed); }
-
     css_error("Invalid CSS", " after ", ": expected expression (e.g. 1px, bold), was ");
 
     // unreachable statement
-    return 0;
+    return {};
   }
 
   // this parses interpolation inside other strings
@@ -1730,7 +1760,7 @@ namespace Sass {
                     find_first_in_interval< exactly<hash_lbrace>, block_comment >(i, chunk.end);
 
     if (!p) {
-      String_Quoted_Ptr str_quoted = SASS_MEMORY_NEW(String_Quoted, pstate, std::string(i, chunk.end), 0, false, false, true, css);
+      String_Quoted* str_quoted = SASS_MEMORY_NEW(String_Quoted, pstate, std::string(i, chunk.end), 0, false, false, true, css);
       if (!constant && str_quoted->quote_mark()) str_quoted->quote_mark('*');
       return str_quoted;
     }
@@ -1774,74 +1804,66 @@ namespace Sass {
     return schema.detach();
   }
 
-  String_Schema_Obj Parser::parse_css_variable_value(bool top_level)
+  String_Schema_Obj Parser::parse_css_variable_value()
   {
     String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);
-    String_Schema_Obj tok;
-    if (!(tok = parse_css_variable_value_token(top_level))) {
-      return NULL;
-    }
-
-    schema->concat(tok);
-    while ((tok = parse_css_variable_value_token(top_level))) {
-      schema->concat(tok);
-    }
-
-    return schema.detach();
-  }
-
-  String_Schema_Obj Parser::parse_css_variable_value_token(bool top_level)
-  {
-    String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);
-    if (
-      (top_level && lex< css_variable_top_level_value >(false)) ||
-      (!top_level && lex< css_variable_value >(false))
-    ) {
-      Token str(lexed);
-      schema->append(SASS_MEMORY_NEW(String_Constant, pstate, str));
-    }
-    else if (Expression_Obj tok = lex_interpolation()) {
-      if (String_Schema_Ptr s = Cast<String_Schema>(tok)) {
-        schema->concat(s);
-      } else {
-        schema->append(tok);
-      }
-    }
-    else if (lex< quoted_string >()) {
-      Expression_Obj tok = parse_string();
-      if (String_Schema_Ptr s = Cast<String_Schema>(tok)) {
-        schema->concat(s);
-      } else {
-        schema->append(tok);
-      }
-    }
-    else {
-      if (peek< alternatives< exactly<'('>, exactly<'['>, exactly<'{'> > >()) {
-        if (lex< exactly<'('> >()) {
-          schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string("(")));
-          if (String_Schema_Obj tok = parse_css_variable_value(false)) schema->concat(tok);
-          if (!lex< exactly<')'> >()) css_error("Invalid CSS", " after ", ": expected \")\", was ");
-          schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(")")));
+    std::vector<char> brackets;
+    while (true) {
+      if (
+        (brackets.empty() && lex< css_variable_top_level_value >(false)) ||
+        (!brackets.empty() && lex< css_variable_value >(false))
+      ) {
+        Token str(lexed);
+        schema->append(SASS_MEMORY_NEW(String_Constant, pstate, str));
+      } else if (Expression_Obj tok = lex_interpolation()) {
+        if (String_Schema* s = Cast<String_Schema>(tok)) {
+          if (s->empty()) break;
+          schema->concat(s);
+        } else {
+          schema->append(tok);
         }
-        else if (lex< exactly<'['> >()) {
-          schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string("[")));
-          if (String_Schema_Obj tok = parse_css_variable_value(false)) schema->concat(tok);
-          if (!lex< exactly<']'> >()) css_error("Invalid CSS", " after ", ": expected \"]\", was ");
-          schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string("]")));
+      } else if (lex< quoted_string >()) {
+        Expression_Obj tok = parse_string();
+        if (tok.isNull()) break;
+        if (String_Schema* s = Cast<String_Schema>(tok)) {
+          if (s->empty()) break;
+          schema->concat(s);
+        } else {
+          schema->append(tok);
         }
-        else if (lex< exactly<'{'> >()) {
-          schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string("{")));
-          if (String_Schema_Obj tok = parse_css_variable_value(false)) schema->concat(tok);
-          if (!lex< exactly<'}'> >()) css_error("Invalid CSS", " after ", ": expected \"}\", was ");
-          schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string("}")));
+      } else if (lex< alternatives< exactly<'('>, exactly<'['>, exactly<'{'> > >()) {
+        const char opening_bracket = *(position - 1);
+        brackets.push_back(opening_bracket);
+        schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(1, opening_bracket)));
+      } else if (const char *match = peek< alternatives< exactly<')'>, exactly<']'>, exactly<'}'> > >()) {
+        if (brackets.empty()) break;
+        const char closing_bracket = *(match - 1);
+        if (brackets.back() != Util::opening_bracket_for(closing_bracket)) {
+          std::string message = ": expected \"";
+          message += Util::closing_bracket_for(brackets.back());
+          message += "\", was ";
+          css_error("Invalid CSS", " after ", message);
         }
+        lex< alternatives< exactly<')'>, exactly<']'>, exactly<'}'> > >();
+        schema->append(SASS_MEMORY_NEW(String_Constant, pstate, std::string(1, closing_bracket)));
+        brackets.pop_back();
+      } else {
+        break;
       }
     }
 
-    return schema->length() > 0 ? schema.detach() : NULL;
+    if (!brackets.empty()) {
+      std::string message = ": expected \"";
+      message += Util::closing_bracket_for(brackets.back());
+      message += "\", was ";
+      css_error("Invalid CSS", " after ", message);
+    }
+
+    if (schema->empty()) error("Custom property values may not be empty.");
+    return schema.detach();
   }
 
-  String_Constant_Obj Parser::parse_static_value()
+  Value_Obj Parser::parse_static_value()
   {
     lex< static_value >();
     Token str(lexed);
@@ -1852,8 +1874,7 @@ namespace Sass {
     --str.end;
     --position;
 
-    String_Constant_Ptr str_node = SASS_MEMORY_NEW(String_Constant, pstate, str.time_wspace());
-    return str_node;
+    return color_or_string(str.time_wspace());;
   }
 
   String_Obj Parser::parse_string()
@@ -1872,7 +1893,7 @@ namespace Sass {
       return SASS_MEMORY_NEW(String_Quoted, pstate, std::string(str.begin, str.end));
     }
 
-    String_Schema_Ptr schema = SASS_MEMORY_NEW(String_Schema, pstate);
+    String_Schema* schema = SASS_MEMORY_NEW(String_Schema, pstate);
     while (i < str.end) {
       p = find_first_in_interval< exactly<hash_lbrace>, block_comment >(i, str.end);
       if (p) {
@@ -1907,7 +1928,7 @@ namespace Sass {
 
   String_Obj Parser::parse_ie_keyword_arg()
   {
-    String_Schema_Ptr kwd_arg = SASS_MEMORY_NEW(String_Schema, pstate, 3);
+    String_Schema_Obj kwd_arg = SASS_MEMORY_NEW(String_Schema, pstate, 3);
     if (lex< variable >()) {
       kwd_arg->append(SASS_MEMORY_NEW(Variable, pstate, Util::normalize_underscores(lexed)));
     } else {
@@ -1962,7 +1983,7 @@ namespace Sass {
         if (lex< re_static_expression >()) {
           ex = SASS_MEMORY_NEW(String_Constant, pstate, lexed);
         } else {
-          ex = parse_list();
+          ex = parse_list(true);
         }
         ex->is_interpolant(true);
         schema->append(ex);
@@ -1986,7 +2007,7 @@ namespace Sass {
         }
         if (peek < exactly < '-' > >()) break;
       }
-      else if (lex< sequence < identifier > >()) {
+      else if (lex< identifier >()) {
         schema->append(SASS_MEMORY_NEW(String_Constant, pstate, lexed));
         if ((*position == '"' || *position == '\'') || peek < alternatives < alpha > >()) {
            // need_space = true;
@@ -2128,7 +2149,7 @@ namespace Sass {
       uri = url_string->to_string({ NESTED, 5 });
     }
 
-    if (String_Schema_Ptr schema = Cast<String_Schema>(url_string)) {
+    if (String_Schema* schema = Cast<String_Schema>(url_string)) {
       String_Schema_Obj res = SASS_MEMORY_NEW(String_Schema, pstate);
       res->append(SASS_MEMORY_NEW(String_Constant, pstate, prefix));
       res->append(schema);
@@ -2155,6 +2176,7 @@ namespace Sass {
       while (pp && peek< exactly< hash_lbrace > >(pp)) {
         pp = sequence< interpolant, real_uri_value >(pp);
       }
+      if (!pp) return {};
       position = pp;
       return parse_interpolated_chunk(Token(p, position));
     }
@@ -2163,7 +2185,7 @@ namespace Sass {
       return SASS_MEMORY_NEW(String_Constant, pstate, res);
     }
 
-    return 0;
+    return {};
   }
 
   Function_Call_Obj Parser::parse_function_call()
@@ -2179,18 +2201,21 @@ namespace Sass {
     return SASS_MEMORY_NEW(Function_Call, call_pos, name, args);
   }
 
-  Function_Call_Schema_Obj Parser::parse_function_call_schema()
+  Function_Call_Obj Parser::parse_function_call_schema()
   {
     String_Obj name = parse_identifier_schema();
     ParserState source_position_of_call = pstate;
     Arguments_Obj args = parse_arguments();
 
-    return SASS_MEMORY_NEW(Function_Call_Schema, source_position_of_call, name, args);
+    return SASS_MEMORY_NEW(Function_Call, source_position_of_call, name, args);
   }
 
   Content_Obj Parser::parse_content_directive()
   {
-    return SASS_MEMORY_NEW(Content, pstate);
+    ParserState call_pos = pstate;
+    Arguments_Obj args = parse_arguments();
+
+    return SASS_MEMORY_NEW(Content, call_pos, args);
   }
 
   If_Obj Parser::parse_if_directive(bool else_if)
@@ -2200,7 +2225,7 @@ namespace Sass {
     bool root = block_stack.back()->is_root();
     Expression_Obj predicate = parse_list();
     Block_Obj block = parse_block(root);
-    Block_Obj alternative = NULL;
+    Block_Obj alternative;
 
     // only throw away comment if we parse a case
     // we want all other comments to be parsed
@@ -2285,7 +2310,7 @@ namespace Sass {
     stack.push_back(Scope::Control);
     bool root = block_stack.back()->is_root();
     // create the initial while call object
-    While_Obj call = SASS_MEMORY_NEW(While, pstate, 0, 0);
+    While_Obj call = SASS_MEMORY_NEW(While, pstate, {}, {});
     // parse mandatory predicate
     Expression_Obj predicate = parse_list();
     List_Obj l = Cast<List>(predicate);
@@ -2305,7 +2330,7 @@ namespace Sass {
   Media_Block_Obj Parser::parse_media_block()
   {
     stack.push_back(Scope::Media);
-    Media_Block_Obj media_block = SASS_MEMORY_NEW(Media_Block, pstate, 0, 0);
+    Media_Block_Obj media_block = SASS_MEMORY_NEW(Media_Block, pstate, {}, {});
 
     media_block->media_queries(parse_media_queries());
 
@@ -2327,7 +2352,7 @@ namespace Sass {
     return queries.detach();
   }
 
-  // Expression_Ptr Parser::parse_media_query()
+  // Expression* Parser::parse_media_query()
   Media_Query_Obj Parser::parse_media_query()
   {
     advanceToNextToken();
@@ -2341,7 +2366,7 @@ namespace Sass {
 
     while (lex_css < kwd_and >()) media_query->append(parse_media_expression());
     if (lex < identifier_schema >()) {
-      String_Schema_Ptr schema = SASS_MEMORY_NEW(String_Schema, pstate);
+      String_Schema* schema = SASS_MEMORY_NEW(String_Schema, pstate);
       schema->append(media_query->media_type());
       schema->append(SASS_MEMORY_NEW(String_Constant, pstate, " "));
       schema->append(parse_identifier_schema());
@@ -2358,7 +2383,7 @@ namespace Sass {
   {
     if (lex < identifier_schema >()) {
       String_Obj ss = parse_identifier_schema();
-      return SASS_MEMORY_NEW(Media_Query_Expression, pstate, ss, 0, true);
+      return SASS_MEMORY_NEW(Media_Query_Expression, pstate, ss, {}, true);
     }
     if (!lex_css< exactly<'('> >()) {
       error("media query expression must begin with '('");
@@ -2368,7 +2393,7 @@ namespace Sass {
       error("media feature required in media query expression");
     }
     feature = parse_expression();
-    Expression_Obj expression = 0;
+    Expression_Obj expression;
     if (lex_css< exactly<':'> >()) {
       expression = parse_list(DELAYED);
     }
@@ -2382,10 +2407,7 @@ namespace Sass {
   // these are very similar to media blocks
   Supports_Block_Obj Parser::parse_supports_directive()
   {
-    Supports_Condition_Obj cond = parse_supports_condition();
-    if (!cond) {
-      css_error("Invalid CSS", " after ", ": expected @supports condition (e.g. (display: flexbox)), was ", false);
-    }
+    Supports_Condition_Obj cond = parse_supports_condition(/*top_level=*/true);
     // create the ast node object for the support queries
     Supports_Block_Obj query = SASS_MEMORY_NEW(Supports_Block, pstate, cond);
     // additional block is mandatory
@@ -2397,27 +2419,27 @@ namespace Sass {
 
   // parse one query operation
   // may encounter nested queries
-  Supports_Condition_Obj Parser::parse_supports_condition()
+  Supports_Condition_Obj Parser::parse_supports_condition(bool top_level)
   {
     lex < css_whitespace >();
     Supports_Condition_Obj cond;
     if ((cond = parse_supports_negation())) return cond;
-    if ((cond = parse_supports_operator())) return cond;
+    if ((cond = parse_supports_operator(top_level))) return cond;
     if ((cond = parse_supports_interpolation())) return cond;
     return cond;
   }
 
   Supports_Condition_Obj Parser::parse_supports_negation()
   {
-    if (!lex < kwd_not >()) return 0;
-    Supports_Condition_Obj cond = parse_supports_condition_in_parens();
+    if (!lex < kwd_not >()) return {};
+    Supports_Condition_Obj cond = parse_supports_condition_in_parens(/*parens_required=*/true);
     return SASS_MEMORY_NEW(Supports_Negation, pstate, cond);
   }
 
-  Supports_Condition_Obj Parser::parse_supports_operator()
+  Supports_Condition_Obj Parser::parse_supports_operator(bool top_level)
   {
-    Supports_Condition_Obj cond = parse_supports_condition_in_parens();
-    if (cond.isNull()) return 0;
+    Supports_Condition_Obj cond = parse_supports_condition_in_parens(/*parens_required=*/top_level);
+    if (cond.isNull()) return {};
 
     while (true) {
       Supports_Operator::Operand op = Supports_Operator::OR;
@@ -2425,9 +2447,9 @@ namespace Sass {
       else if(!lex < kwd_or >()) { break; }
 
       lex < css_whitespace >();
-      Supports_Condition_Obj right = parse_supports_condition_in_parens();
+      Supports_Condition_Obj right = parse_supports_condition_in_parens(/*parens_required=*/true);
 
-      // Supports_Condition_Ptr cc = SASS_MEMORY_NEW(Supports_Condition, *static_cast<Supports_Condition_Ptr>(cond));
+      // Supports_Condition* cc = SASS_MEMORY_NEW(Supports_Condition, *static_cast<Supports_Condition*>(cond));
       cond = SASS_MEMORY_NEW(Supports_Operator, pstate, cond, right, op);
     }
     return cond;
@@ -2435,10 +2457,10 @@ namespace Sass {
 
   Supports_Condition_Obj Parser::parse_supports_interpolation()
   {
-    if (!lex < interpolant >()) return 0;
+    if (!lex < interpolant >()) return {};
 
     String_Obj interp = parse_interpolated_chunk(lexed);
-    if (!interp) return 0;
+    if (!interp) return {};
 
     return SASS_MEMORY_NEW(Supports_Interpolation, pstate, interp);
   }
@@ -2447,10 +2469,10 @@ namespace Sass {
   // look like declarations their semantics differ significantly
   Supports_Condition_Obj Parser::parse_supports_declaration()
   {
-    Supports_Condition_Ptr cond;
+    Supports_Condition* cond;
     // parse something declaration like
     Expression_Obj feature = parse_expression();
-    Expression_Obj expression = 0;
+    Expression_Obj expression;
     if (lex_css< exactly<':'> >()) {
       expression = parse_list(DELAYED);
     }
@@ -2463,21 +2485,24 @@ namespace Sass {
     return cond;
   }
 
-  Supports_Condition_Obj Parser::parse_supports_condition_in_parens()
+  Supports_Condition_Obj Parser::parse_supports_condition_in_parens(bool parens_required)
   {
     Supports_Condition_Obj interp = parse_supports_interpolation();
     if (interp != 0) return interp;
 
-    if (!lex < exactly <'('> >()) return 0;
+    if (!lex < exactly <'('> >()) {
+      if (parens_required) {
+        css_error("Invalid CSS", " after ", ": expected @supports condition (e.g. (display: flexbox)), was ", /*trim=*/false);
+      } else {
+        return {};
+      }
+    }
     lex < css_whitespace >();
 
-    Supports_Condition_Obj cond = parse_supports_condition();
-    if (cond != 0) {
-      if (!lex < exactly <')'> >()) error("unclosed parenthesis in @supports declaration");
-    } else {
-      cond = parse_supports_declaration();
-      if (!lex < exactly <')'> >()) error("unclosed parenthesis in @supports declaration");
-    }
+    Supports_Condition_Obj cond = parse_supports_condition(/*top_level=*/false);
+    if (cond.isNull()) cond = parse_supports_declaration();
+    if (!lex < exactly <')'> >()) error("unclosed parenthesis in @supports declaration");
+
     lex < css_whitespace >();
     return cond;
   }
@@ -2486,7 +2511,7 @@ namespace Sass {
   {
     stack.push_back(Scope::AtRoot);
     ParserState at_source_position = pstate;
-    Block_Obj body = 0;
+    Block_Obj body;
     At_Root_Query_Obj expr;
     Lookahead lookahead_result;
     if (lex_css< exactly<'('> >()) {
@@ -2541,7 +2566,7 @@ namespace Sass {
 
     // this whole branch is never hit via spec tests
 
-    Directive_Ptr at_rule = SASS_MEMORY_NEW(Directive, pstate, kwd);
+    Directive* at_rule = SASS_MEMORY_NEW(Directive, pstate, kwd);
     Lookahead lookahead = lookahead_for_include(position);
     if (lookahead.found && !lookahead.has_interpolants) {
       at_rule->selector(parse_selector_list(false));
@@ -2612,7 +2637,7 @@ namespace Sass {
     if (lex < interpolant >(true) != NULL) {
       return parse_interpolated_chunk(lexed, true);
     }
-    return 0;
+    return {};
   }
 
   Expression_Obj Parser::lex_interp_uri()
@@ -2678,30 +2703,32 @@ namespace Sass {
     if (match) {
       return SASS_MEMORY_NEW(String_Constant, pstate, lexed);
     }
-    return NULL;
+    return {};
   }
 
   Expression_Obj Parser::lex_almost_any_value_token()
   {
     Expression_Obj rv;
-    if (*position == 0) return 0;
+    if (*position == 0) return {};
     if ((rv = lex_almost_any_value_chars())) return rv;
     // if ((rv = lex_block_comment())) return rv;
     // if ((rv = lex_single_line_comment())) return rv;
     if ((rv = lex_interp_string())) return rv;
     if ((rv = lex_interp_uri())) return rv;
     if ((rv = lex_interpolation())) return rv;
-    return rv;
+     if (lex< alternatives< hex, hex0 > >())
+    { return lexed_hex_color(lexed); }
+   return rv;
   }
 
   String_Schema_Obj Parser::parse_almost_any_value()
   {
 
     String_Schema_Obj schema = SASS_MEMORY_NEW(String_Schema, pstate);
-    if (*position == 0) return 0;
+    if (*position == 0) return {};
     lex < spaces >(false);
     Expression_Obj token = lex_almost_any_value_token();
-    if (!token) return 0;
+    if (!token) return {};
     schema->append(token);
     if (*position == 0) {
       schema->rtrim();
@@ -2777,6 +2804,7 @@ namespace Sass {
       >(p)
     ) {
       bool could_be_property = peek< sequence< exactly<'-'>, exactly<'-'> > >(p) != 0;
+      bool could_be_escaped = false;
       while (p < q) {
         // did we have interpolations?
         if (*p == '#' && *(p+1) == '{') {
@@ -2785,9 +2813,10 @@ namespace Sass {
         }
         // A property that's ambiguous with a nested selector is interpreted as a
         // custom property.
-        if (*p == ':') {
+        if (*p == ':' && !could_be_escaped) {
           rv.is_custom_property = could_be_property || p+1 == q || peek< space >(p+1);
         }
+        could_be_escaped = *p == '\\';
         ++ p;
       }
       // store anyway  }
@@ -2981,7 +3010,7 @@ namespace Sass {
 
   Expression_Obj Parser::fold_operands(Expression_Obj base, std::vector<Expression_Obj>& operands, std::vector<Operand>& ops, size_t i)
   {
-    if (String_Schema_Ptr schema = Cast<String_Schema>(base)) {
+    if (String_Schema* schema = Cast<String_Schema>(base)) {
       // return schema;
       if (schema->has_interpolants()) {
         if (i + 1 < operands.size() && (
@@ -3004,7 +3033,7 @@ namespace Sass {
     }
 
     for (size_t S = operands.size(); i < S; ++i) {
-      if (String_Schema_Ptr schema = Cast<String_Schema>(operands[i])) {
+      if (String_Schema* schema = Cast<String_Schema>(operands[i])) {
         if (schema->has_interpolants()) {
           if (i + 1 < S) {
             // this whole branch is never hit via spec tests
@@ -3021,13 +3050,13 @@ namespace Sass {
       } else {
         base = SASS_MEMORY_NEW(Binary_Expression, base->pstate(), ops[i], base, operands[i]);
       }
-      Binary_Expression_Ptr b = Cast<Binary_Expression>(base.ptr());
+      Binary_Expression* b = Cast<Binary_Expression>(base.ptr());
       if (b && ops[i].operand == Sass_OP::DIV && b->left()->is_delayed() && b->right()->is_delayed()) {
         base->is_delayed(true);
       }
     }
     // nested binary expression are never to be delayed
-    if (Binary_Expression_Ptr b = Cast<Binary_Expression>(base)) {
+    if (Binary_Expression* b = Cast<Binary_Expression>(base)) {
       if (Cast<Binary_Expression>(b->left())) base->set_delayed(false);
       if (Cast<Binary_Expression>(b->right())) base->set_delayed(false);
     }
@@ -3038,8 +3067,11 @@ namespace Sass {
   {
     Position p(pos.line ? pos : before_token);
     ParserState pstate(path, source, p, Offset(0, 0));
+    // `pstate.src` may not outlive stack unwind so we must copy it.
+    char *src_copy = sass_copy_c_string(pstate.src);
+    pstate.src = src_copy;
     traces.push_back(Backtrace(pstate));
-    throw Exception::InvalidSass(pstate, traces, msg);
+    throw Exception::InvalidSass(pstate, traces, msg, src_copy);
   }
 
   void Parser::error(std::string msg)