sassc 1.10.1 → 1.11.0

data/ext/libsass/src/error_handling.cpp

@@ -35,11 +35,19 @@ namespace Sass {
     : Base(pstate), fn(fn), arg(arg), type(type), value(value)
     {
       msg  = arg + ": \"";
-      msg += value->to_string(Sass_Inspect_Options());
+      if (value) msg += value->to_string(Sass_Inspect_Options());
       msg += "\" is not a " + type;
       msg += " for `" + fn + "'";
     }
 
+    MissingArgument::MissingArgument(ParserState pstate, std::string fn, std::string arg, std::string fntype)
+    : Base(pstate), fn(fn), arg(arg), fntype(fntype)
+    {
+      msg  = fntype + " " + fn;
+      msg += " is missing argument ";
+      msg += arg + ".";
+    }
+
     InvalidSyntax::InvalidSyntax(ParserState pstate, std::string msg, std::vector<Sass_Import_Entry>* import_stack)
     : Base(pstate, msg, import_stack)
     { }
@@ -74,7 +82,6 @@ namespace Sass {
     : Base(org.pstate()), dup(dup), org(org)
     {
       msg  = "Duplicate key ";
-      dup.get_duplicate_key()->is_delayed(false);
       msg += dup.get_duplicate_key()->inspect();
       msg += " in map (";
       msg += org.inspect();
@@ -97,6 +104,12 @@ namespace Sass {
       msg += " isn't a valid CSS value.";
     }
 
+    StackError::StackError(const AST_Node& node)
+    : Base(node.pstate()), node(node)
+    {
+      msg  = "stack level too deep";
+    }
+
     IncompatibleUnits::IncompatibleUnits(const Number& lhs, const Number& rhs)
     : lhs(lhs), rhs(rhs)
     {

data/ext/libsass/src/error_handling.hpp

@@ -45,6 +45,16 @@ namespace Sass {
         virtual ~InvalidParent() throw() {};
     };
 
+    class MissingArgument : public Base {
+      protected:
+        std::string fn;
+        std::string arg;
+        std::string fntype;
+      public:
+        MissingArgument(ParserState pstate, std::string fn, std::string arg, std::string fntype);
+        virtual ~MissingArgument() throw() {};
+    };
+
     class InvalidArgumentType : public Base {
       protected:
         std::string fn;
@@ -115,6 +125,15 @@ namespace Sass {
         virtual ~InvalidValue() throw() {};
     };
 
+    class StackError : public Base {
+      protected:
+        const AST_Node& node;
+      public:
+        StackError(const AST_Node& node);
+        virtual const char* errtype() const { return "SystemStackError"; }
+        virtual ~StackError() throw() {};
+    };
+
     class IncompatibleUnits : public OperationError {
       protected:
         const Number& lhs;

data/ext/libsass/src/eval.cpp

@@ -31,7 +31,14 @@ namespace Sass {
   inline double sub(double x, double y) { return x - y; }
   inline double mul(double x, double y) { return x * y; }
   inline double div(double x, double y) { return x / y; } // x/0 checked by caller
-  inline double mod(double x, double y) { return std::abs(std::fmod(x, y)); } // x/0 checked by caller
+  inline double mod(double x, double y) { // x/0 checked by caller
+    if ((x > 0 && y < 0) || (x < 0 && y > 0)) {
+      double ret = std::fmod(x, y);
+      return ret ? ret + y : ret;
+    } else {
+      return std::fmod(x, y);
+    }
+  }
   typedef double (*bop)(double, double);
   bop ops[Sass_OP::NUM_OPS] = {
     0, 0, // and, or
@@ -41,7 +48,9 @@ namespace Sass {
 
   Eval::Eval(Expand& exp)
   : exp(exp),
-    ctx(exp.ctx)
+    ctx(exp.ctx),
+    force(false),
+    is_in_comment(false)
   { }
   Eval::~Eval() { }
 
@@ -55,7 +64,7 @@ namespace Sass {
     return exp.environment();
   }
 
-  Selector_List* Eval::selector()
+  CommaSequence_Selector* Eval::selector()
   {
     return exp.selector();
   }
@@ -221,7 +230,7 @@ namespace Sass {
     if (expr->concrete_type() == Expression::MAP) {
       map = static_cast<Map*>(expr);
     }
-    else if (Selector_List* ls = dynamic_cast<Selector_List*>(expr)) {
+    else if (CommaSequence_Selector* ls = dynamic_cast<CommaSequence_Selector*>(expr)) {
       Listize listize(ctx.mem);
       list = dynamic_cast<List*>(ls->perform(&listize));
     }
@@ -255,7 +264,7 @@ namespace Sass {
       }
     }
     else {
-      if (list->length() == 1 && dynamic_cast<Selector_List*>(list)) {
+      if (list->length() == 1 && dynamic_cast<CommaSequence_Selector*>(list)) {
         list = dynamic_cast<Vectorized<Expression*>*>(list);
       }
       for (size_t i = 0, L = list->length(); i < L; ++i) {
@@ -436,7 +445,7 @@ namespace Sass {
         Expression* key = (*l)[i+0]->perform(this);
         Expression* val = (*l)[i+1]->perform(this);
         // make sure the color key never displays its real name
-        key->is_delayed(true);
+        key->is_delayed(true); // verified
         *lm << std::make_pair(key, val);
       }
       if (lm->has_duplicate_key()) {
@@ -497,21 +506,13 @@ namespace Sass {
     String_Schema* ret_schema = 0;
     enum Sass_OP op_type = b->type();
 
-    // don't eval delayed expressions (the '/' when used as a separator)
-    if (op_type == Sass_OP::DIV && b->is_delayed()) {
-      b->right(b->right()->perform(this));
-      b->left(b->left()->perform(this));
-      return b;
-    }
-
     // only the last item will be used to eval the binary expression
     if (String_Schema* s_l = dynamic_cast<String_Schema*>(b->left())) {
       if (!s_l->has_interpolant() && (!s_l->is_right_interpolant())) {
-        ret_schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, s_l->pstate());
+        ret_schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, b->pstate());
         Binary_Expression* bin_ex = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, b->pstate(),
                                                     b->op(), s_l->last(), b->right());
-        bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed());
-        // bin_ex->is_interpolant(b->left()->is_interpolant());
+        bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed()); // unverified
         for (size_t i = 0; i < s_l->length() - 1; ++i) {
           *ret_schema << s_l->at(i)->perform(this);
         }
@@ -521,11 +522,10 @@ namespace Sass {
     }
     if (String_Schema* s_r = dynamic_cast<String_Schema*>(b->right())) {
       if (!s_r->has_interpolant() && (!s_r->is_left_interpolant() || op_type == Sass_OP::DIV)) {
-        ret_schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, s_r->pstate());
+        ret_schema = SASS_MEMORY_NEW(ctx.mem, String_Schema, b->pstate());
         Binary_Expression* bin_ex = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, b->pstate(),
                                                     b->op(), b->left(), s_r->first());
-        bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed());
-        // if (op_type == Sass_OP::SUB && b->is_right_interpolant()) bin_ex->is_interpolant(true);
+        bin_ex->is_delayed(b->left()->is_delayed() || b->right()->is_delayed()); // verified
         *ret_schema << bin_ex->perform(this);
         for (size_t i = 1; i < s_r->length(); ++i) {
           *ret_schema << s_r->at(i)->perform(this);
@@ -535,34 +535,18 @@ namespace Sass {
     }
 
 
+    b = SASS_MEMORY_NEW(ctx.mem, Binary_Expression, *b);
     // don't eval delayed expressions (the '/' when used as a separator)
-    if (op_type == Sass_OP::DIV && b->is_delayed()) {
+    if (!force && op_type == Sass_OP::DIV && b->is_delayed()) {
       b->right(b->right()->perform(this));
       b->left(b->left()->perform(this));
       return b;
     }
 
-    // b->is_delayed(false);
     Expression* lhs = b->left();
     Expression* rhs = b->right();
 
-    // bool delay_lhs = false;
-    // bool delay_rhs = false;
-
-    if (String_Schema* schema = dynamic_cast<String_Schema*>(lhs)) {
-      if (schema->is_right_interpolant()) {
-        b->is_delayed(true);
-        // delay_lhs = true;
-      }
-    }
-    if (String_Schema* schema = dynamic_cast<String_Schema*>(rhs)) {
-      if (schema->is_left_interpolant()) {
-        b->is_delayed(true);
-        // delay_rhs = true;
-      }
-    }
-
-    // maybe fully evaluate structure
+    // fully evaluate their values
     if (op_type == Sass_OP::EQ ||
         op_type == Sass_OP::NEQ ||
         op_type == Sass_OP::GT ||
@@ -570,43 +554,16 @@ namespace Sass {
         op_type == Sass_OP::LT ||
         op_type == Sass_OP::LTE)
     {
-
-      if (String_Schema* schema = dynamic_cast<String_Schema*>(lhs)) {
-        if (schema->has_interpolants()) {
-          b->is_delayed(true);
-        }
-      }
-      if (String_Schema* schema = dynamic_cast<String_Schema*>(rhs)) {
-        if (schema->has_interpolants()) {
-          b->is_delayed(true);
-        }
-      }
-      lhs->is_expanded(false);
-      lhs->set_delayed(false);
-      lhs = lhs->perform(this);
+      LOCAL_FLAG(force, true);
       lhs->is_expanded(false);
       lhs->set_delayed(false);
       lhs = lhs->perform(this);
       rhs->is_expanded(false);
       rhs->set_delayed(false);
       rhs = rhs->perform(this);
-      rhs->is_expanded(false);
-      rhs->set_delayed(false);
-      rhs = rhs->perform(this);
-    }
-    else
-    {
-      // rhs->set_delayed(false);
-      // rhs = rhs->perform(this);
     }
-
-    // if one of the operands is a '/' then make sure it's evaluated
-    lhs = lhs->perform(this);
-    lhs->is_delayed(false);
-    while (typeid(*lhs) == typeid(Binary_Expression)) {
-      Binary_Expression* lhs_ex = static_cast<Binary_Expression*>(lhs);
-      if (lhs_ex->type() == Sass_OP::DIV && lhs_ex->is_delayed()) break;
-      lhs = Eval::operator()(lhs_ex);
+    else {
+      lhs = lhs->perform(this);
     }
 
     switch (op_type) {
@@ -624,19 +581,6 @@ namespace Sass {
     // not a logical connective, so go ahead and eval the rhs
     rhs = rhs->perform(this);
 
-    // upgrade string to number if possible (issue #948)
-    if (op_type == Sass_OP::DIV || op_type == Sass_OP::MUL) {
-      if (String_Constant* str = dynamic_cast<String_Constant*>(rhs)) {
-        std::string value(str->value());
-        const char* start = value.c_str();
-        if (Prelexer::sequence < Prelexer::number >(start) != 0) {
-          rhs = SASS_MEMORY_NEW(ctx.mem, Textual, rhs->pstate(), Textual::DIMENSION, str->value());
-          rhs->is_delayed(false); rhs = rhs->perform(this);
-        }
-      }
-    }
-
-
     Expression::Concrete_Type l_type = lhs->concrete_type();
     Expression::Concrete_Type r_type = rhs->concrete_type();
 
@@ -662,16 +606,16 @@ namespace Sass {
           std::string value(str->value());
           const char* start = value.c_str();
           if (Prelexer::sequence < Prelexer::dimension, Prelexer::end_of_file >(start) != 0) {
-            lhs = SASS_MEMORY_NEW(ctx.mem, Textual, lhs->pstate(), Textual::DIMENSION, str->value());
-            lhs->is_delayed(false); lhs = lhs->perform(this);
+            lhs = SASS_MEMORY_NEW(ctx.mem, Textual, b->pstate(), Textual::DIMENSION, str->value());
+            lhs = lhs->perform(this);
           }
         }
         if (String_Constant* str = dynamic_cast<String_Constant*>(rhs)) {
           std::string value(str->value());
           const char* start = value.c_str();
           if (Prelexer::sequence < Prelexer::number >(start) != 0) {
-            rhs = SASS_MEMORY_NEW(ctx.mem, Textual, rhs->pstate(), Textual::DIMENSION, str->value());
-            rhs->is_delayed(false); rhs = rhs->perform(this);
+            rhs = SASS_MEMORY_NEW(ctx.mem, Textual, b->pstate(), Textual::DIMENSION, str->value());
+            rhs = rhs->perform(this);
           }
         }
       }
@@ -699,7 +643,7 @@ namespace Sass {
         str += b->separator();
         if (b->op().ws_after) str += " ";
         str += v_r->to_string(ctx.c_options);
-        String_Constant* val = SASS_MEMORY_NEW(ctx.mem, String_Constant, lhs->pstate(), str);
+        String_Constant* val = SASS_MEMORY_NEW(ctx.mem, String_Constant, b->pstate(), str);
         val->is_interpolant(b->left()->has_interpolant());
         return val;
       }
@@ -760,6 +704,13 @@ namespace Sass {
                            b->is_interpolant();
         if (op_type == Sass_OP::SUB) interpolant = false;
         // if (op_type == Sass_OP::DIV) interpolant = true;
+        // check for type violations
+        if (l_type == Expression::MAP) {
+          throw Exception::InvalidValue(*v_l);
+        }
+        if (r_type == Expression::MAP) {
+          throw Exception::InvalidValue(*v_r);
+        }
         Value* ex = op_strings(ctx.mem, b->op(), *v_l, *v_r, ctx.c_options, &pstate, !interpolant); // pass true to compress
         if (String_Constant* str = dynamic_cast<String_Constant*>(ex))
         {
@@ -815,7 +766,20 @@ namespace Sass {
       if (operand->concrete_type() == Expression::NULL_VAL && dynamic_cast<Variable*>(u->operand())) {
         u->operand(SASS_MEMORY_NEW(ctx.mem, String_Quoted, u->pstate(), ""));
       }
-      else u->operand(operand);
+      // Never apply unary opertions on colors @see #2140
+      else if (operand->concrete_type() == Expression::COLOR) {
+        Color* c = dynamic_cast<Color*>(operand);
+
+        // Use the color name if this was eval with one
+        if (c->disp().length() > 0) {
+          operand = SASS_MEMORY_NEW(ctx.mem, String_Constant, operand->pstate(), c->disp());
+          u->operand(operand);
+        }
+      }
+      else {
+        u->operand(operand);
+      }
+
       String_Constant* result = SASS_MEMORY_NEW(ctx.mem, String_Quoted,
                                                   u->pstate(),
                                                   u->inspect());
@@ -837,26 +801,12 @@ namespace Sass {
     std::string full_name(name + "[f]");
     Arguments* args = SASS_MEMORY_NEW(ctx.mem, Arguments, *c->arguments());
 
-    // handle call here if valid arg
-    // otherwise we eval arguments to early
-    if (name == "call" && args->length() > 0) {
-      Expression* redirect = args->at(0)->perform(this);
-      args->erase(args->begin());
-      Function_Call* lit = SASS_MEMORY_NEW(ctx.mem, Function_Call,
-                                           c->pstate(),
-                                           unquote(redirect->to_string()),
-                                           args);
-      return operator()(lit);
-    }
-
     Env* env = environment();
     if (!env->has(full_name)) {
       if (!env->has("*[f]")) {
-        // just pass it through as a literal
-        for (Argument* arg : *args) {
-          if (Binary_Expression* b = dynamic_cast<Binary_Expression*>(arg->value())) {
-            b->reset_whitespace();
-            arg->is_delayed(b->can_delay()); // delay
+        for (Argument* arg : args->elements()) {
+          if (List* ls = dynamic_cast<List*>(arg->value())) {
+            if (ls->size() == 0) error("() isn't a valid CSS value.", c->pstate());
           }
         }
         args = static_cast<Arguments*>(args->perform(this));
@@ -878,16 +828,26 @@ namespace Sass {
       }
     }
 
+    // further delay for calls
+    if (full_name != "call[f]") {
+      args->set_delayed(false); // verified
+    }
     if (full_name != "if[f]") {
       args = static_cast<Arguments*>(args->perform(this));
     }
-
     Definition* def = static_cast<Definition*>((*env)[full_name]);
 
     if (def->is_overload_stub()) {
       std::stringstream ss;
-      ss << full_name
-         << args->length();
+      size_t L = args->length();
+      // account for rest arguments
+      if (args->has_rest_argument() && args->length() > 0) {
+        // get the rest arguments list
+        List* rest = dynamic_cast<List*>(args->last()->value());
+        // arguments before rest argument plus rest
+        if (rest) L += rest->length() - 1;
+      }
+      ss << full_name << L;
       full_name = ss.str();
       std::string resolved_name(full_name);
       if (!env->has(resolved_name)) error("overloaded function `" + std::string(c->name()) + "` given wrong number of arguments", c->pstate());
@@ -908,8 +868,8 @@ namespace Sass {
       Backtrace here(backtrace(), c->pstate(), ", in function `" + c->name() + "`");
       exp.backtrace_stack.push_back(&here);
       // eval the body if user-defined or special, invoke underlying CPP function if native
-      if (body && !Prelexer::re_special_fun(c->name().c_str())) { result = body->perform(this); }
-      else if (func) { result = func(fn_env, *env, ctx, def->signature(), c->pstate(), backtrace()); }
+      if (body && !Prelexer::re_special_fun(name.c_str())) { result = body->perform(this); }
+      else if (func) { result = func(fn_env, *env, ctx, def->signature(), c->pstate(), backtrace(), exp.selector_stack); }
       if (!result) error(std::string("Function ") + c->name() + " did not return a value", c->pstate());
       exp.backtrace_stack.pop_back();
     }
@@ -960,8 +920,7 @@ namespace Sass {
     if (result->pstate().file == std::string::npos)
       result->pstate(c->pstate());
 
-    result->is_delayed(result->concrete_type() == Expression::STRING);
-    if (!result->is_delayed()) result = result->perform(this);
+    result = result->perform(this);
     result->is_interpolant(c->is_interpolant());
     exp.env_stack.pop_back();
     return result;
@@ -990,35 +949,13 @@ namespace Sass {
       value = SASS_MEMORY_NEW(ctx.mem, Number, *static_cast<Number*>(value));
       static_cast<Number*>(value)->zero(true);
     }
-    else if (value->concrete_type() == Expression::STRING) {
-      if (auto str = dynamic_cast<String_Quoted*>(value)) {
-        value = SASS_MEMORY_NEW(ctx.mem, String_Quoted, *str);
-      } else if (auto str = dynamic_cast<String_Constant*>(value)) {
-        value = SASS_MEMORY_NEW(ctx.mem, String_Quoted, str->pstate(), str->value());
-      }
-    }
-    else if (value->concrete_type() == Expression::LIST) {
-      value = SASS_MEMORY_NEW(ctx.mem, List, *static_cast<List*>(value));
-    }
-    else if (value->concrete_type() == Expression::MAP) {
-      value = SASS_MEMORY_NEW(ctx.mem, Map, *static_cast<Map*>(value));
-    }
-    else if (value->concrete_type() == Expression::BOOLEAN) {
-      value = SASS_MEMORY_NEW(ctx.mem, Boolean, *static_cast<Boolean*>(value));
-    }
-    else if (value->concrete_type() == Expression::COLOR) {
-      value = SASS_MEMORY_NEW(ctx.mem, Color, *static_cast<Color*>(value));
-    }
-    else if (value->concrete_type() == Expression::NULL_VAL) {
-      value = SASS_MEMORY_NEW(ctx.mem, Null, value->pstate());
-    }
-    else if (value->concrete_type() == Expression::SELECTOR) {
-      value = value->perform(this); // ->perform(&listize);
-    }
 
     value->is_interpolant(v->is_interpolant());
-    value->is_expanded(false);
-    return value->perform(this);
+    if (force) value->is_expanded(false);
+    value->set_delayed(false); // verified
+    value = value->perform(this);
+    if(!force) (*env)[name] = value;
+    return value;
   }
 
   Expression* Eval::operator()(Textual* t)
@@ -1095,6 +1032,11 @@ namespace Sass {
     return result;
   }
 
+  Expression* Eval::operator()(Color* c)
+  {
+    return c;
+  }
+
   Expression* Eval::operator()(Number* n)
   {
     return n;
@@ -1153,14 +1095,23 @@ namespace Sass {
         bool is_null = dynamic_cast<Null*>(item) != 0; // rl != ""
         if (!is_null) *ll << SASS_MEMORY_NEW(ctx.mem, String_Quoted, item->pstate(), rl);
       }
-      res += (ll->to_string(ctx.c_options));
+      // Check indicates that we probably should not get a list
+      // here. Normally single list items are already unwrapped.
+      if (l->size() > 1) {
+        // string_to_output would fail "#{'_\a' '_\a'}";
+        std::string str(ll->to_string(ctx.c_options));
+        newline_to_space(str); // replace directly
+        res += str; // append to result string
+      } else {
+        res += (ll->to_string(ctx.c_options));
+      }
       ll->is_interpolant(l->is_interpolant());
     }
 
     // Value
     // Textual
     // Function_Call
-    // Selector_List
+    // CommaSequence_Selector
     // String_Quoted
     // String_Constant
     // Parent_Selector
@@ -1201,7 +1152,7 @@ namespace Sass {
       bool is_quoted = dynamic_cast<String_Quoted*>((*s)[i]) != NULL;
       if (was_quoted && !(*s)[i]->is_interpolant() && !was_interpolant) { res += " "; }
       else if (i > 0 && is_quoted && !(*s)[i]->is_interpolant() && !was_interpolant) { res += " "; }
-      Expression* ex = (*s)[i]->is_delayed() ? (*s)[i] : (*s)[i]->perform(this);
+      Expression* ex = (*s)[i]->perform(this);
       interpolation(ctx, res, ex, into_quotes, ex->is_interpolant());
       was_quoted = dynamic_cast<String_Quoted*>((*s)[i]) != NULL;
       was_interpolant = (*s)[i]->is_interpolant();
@@ -1211,7 +1162,8 @@ namespace Sass {
       if (s->length() > 1 && res == "") return SASS_MEMORY_NEW(ctx.mem, Null, s->pstate());
       return SASS_MEMORY_NEW(ctx.mem, String_Constant, s->pstate(), res);
     }
-    String_Quoted* str = SASS_MEMORY_NEW(ctx.mem, String_Quoted, s->pstate(), res);
+    // string schema seems to have a special unquoting behavior (also handles "nested" quotes)
+    String_Quoted* str = SASS_MEMORY_NEW(ctx.mem, String_Quoted, s->pstate(), res, 0, false, false, false);
     // if (s->is_interpolant()) str->quote_mark(0);
     // String_Constant* str = SASS_MEMORY_NEW(ctx.mem, String_Constant, s->pstate(), res);
     if (str->quote_mark()) str->quote_mark('*');
@@ -1227,6 +1179,7 @@ namespace Sass {
       Color* c = SASS_MEMORY_NEW(ctx.mem, Color, *name_to_color(s->value()));
       c->pstate(s->pstate());
       c->disp(s->value());
+      c->is_delayed(true);
       return c;
     }
     return s;
@@ -1343,10 +1296,7 @@ namespace Sass {
   Expression* Eval::operator()(Argument* a)
   {
     Expression* val = a->value();
-    // delay missin function arguments?
-    val->is_delayed(a->is_delayed());
     val = val->perform(this);
-    val->is_delayed(false);
 
     bool is_rest_argument = a->is_rest_argument();
     bool is_keyword_argument = a->is_keyword_argument();
@@ -1606,12 +1556,8 @@ namespace Sass {
     if ( (sep == "") /* &&
          (sep != "/" || !rqstr || !rqstr->quote_mark()) */
     ) {
-      char quote_mark = 0;
-      std::string unq(unquote(lstr + sep + rstr, &quote_mark, true));
-      if (quote_mark && quote_mark != '*') {
-        return SASS_MEMORY_NEW(mem, String_Constant, lhs.pstate(), quote_mark + unq + quote_mark);
-      }
-      return SASS_MEMORY_NEW(mem, String_Quoted, lhs.pstate(), lstr + sep + rstr);
+      // create a new string that might be quoted on output (but do not unquote what we pass)
+      return SASS_MEMORY_NEW(mem, String_Quoted, pstate ? *pstate : lhs.pstate(), lstr + rstr, 0, false, true);
     }
 
     if (sep != "" && !delayed) {
@@ -1622,10 +1568,9 @@ namespace Sass {
     if (op == Sass_OP::SUB || op == Sass_OP::DIV) {
       if (lqstr && lqstr->quote_mark()) lstr = quote(lstr);
       if (rqstr && rqstr->quote_mark()) rstr = quote(rstr);
-      return SASS_MEMORY_NEW(mem, String_Constant, lhs.pstate(), lstr + sep + rstr);
     }
 
-    return SASS_MEMORY_NEW(mem, String_Constant, lhs.pstate(), (lstr) + sep + (rstr));
+    return SASS_MEMORY_NEW(mem, String_Constant, pstate ? *pstate : lhs.pstate(), lstr + sep + rstr);
   }
 
   Expression* cval_to_astnode(Memory_Manager& mem, union Sass_Value* v, Context& ctx, Backtrace* backtrace, ParserState pstate)
@@ -1679,10 +1624,10 @@ namespace Sass {
     return e;
   }
 
-  Selector_List* Eval::operator()(Selector_List* s)
+  CommaSequence_Selector* Eval::operator()(CommaSequence_Selector* s)
   {
-    std::vector<Selector_List*> rv;
-    Selector_List* sl = SASS_MEMORY_NEW(ctx.mem, Selector_List, s->pstate());
+    std::vector<CommaSequence_Selector*> rv;
+    CommaSequence_Selector* sl = SASS_MEMORY_NEW(ctx.mem, CommaSequence_Selector, s->pstate());
     sl->is_optional(s->is_optional());
     sl->media_block(s->media_block());
     sl->is_optional(s->is_optional());
@@ -1712,9 +1657,10 @@ namespace Sass {
   }
 
 
-  Selector_List* Eval::operator()(Complex_Selector* s)
+  CommaSequence_Selector* Eval::operator()(Sequence_Selector* s)
   {
-    return s->parentize(selector(), ctx);
+    bool implicit_parent = !exp.old_at_root_without_rule;
+    return s->resolve_parent_refs(ctx, selector(), implicit_parent);
 
   }
 
@@ -1728,21 +1674,21 @@ namespace Sass {
     return ss;
   }
 
-  Selector_List* Eval::operator()(Selector_Schema* s)
+  CommaSequence_Selector* Eval::operator()(Selector_Schema* s)
   {
     // the parser will look for a brace to end the selector
     std::string result_str(s->contents()->perform(this)->to_string(ctx.c_options));
     result_str = unquote(Util::rtrim(result_str)) + "\n{";
     Parser p = Parser::from_c_str(result_str.c_str(), ctx, s->pstate());
     p.last_media_block = s->media_block();
-    Selector_List* sl = p.parse_selector_list(exp.block_stack.back()->is_root());
+    CommaSequence_Selector* sl = p.parse_selector_list(exp.block_stack.back()->is_root());
     if (s->has_parent_ref()) sl->remove_parent_selectors();
     return operator()(sl);
   }
 
   Expression* Eval::operator()(Parent_Selector* p)
   {
-    Selector_List* pr = selector();
+    CommaSequence_Selector* pr = selector();
     if (pr) {
       exp.selector_stack.pop_back();
       pr = operator()(pr);