sassc 1.11.4 → 1.12.0

data/ext/libsass/src/eval.hpp

@@ -18,16 +18,20 @@ namespace Sass {
     Expression_Ptr fallback_impl(AST_Node_Ptr n);
 
    public:
-    Expand&  exp;
+    Expand& exp;
     Context& ctx;
+    Backtraces& traces;
     Eval(Expand& exp);
     ~Eval();
 
     bool force;
     bool is_in_comment;
+    bool is_in_selector_schema;
+
+    Boolean_Obj bool_true;
+    Boolean_Obj bool_false;
 
     Env* environment();
-    Backtrace* backtrace();
     Selector_List_Obj selector();
 
     // for evaluating function bodies
@@ -49,7 +53,6 @@ namespace Sass {
     Expression_Ptr operator()(Function_Call_Ptr);
     Expression_Ptr operator()(Function_Call_Schema_Ptr);
     Expression_Ptr operator()(Variable_Ptr);
-    Expression_Ptr operator()(Textual_Ptr);
     Expression_Ptr operator()(Number_Ptr);
     Expression_Ptr operator()(Color_Ptr);
     Expression_Ptr operator()(Boolean_Ptr);
@@ -57,7 +60,7 @@ namespace Sass {
     Expression_Ptr operator()(String_Quoted_Ptr);
     Expression_Ptr operator()(String_Constant_Ptr);
     // Expression_Ptr operator()(Selector_List_Ptr);
-    Expression_Ptr operator()(Media_Query_Ptr);
+    Media_Query_Ptr operator()(Media_Query_Ptr);
     Expression_Ptr operator()(Media_Query_Expression_Ptr);
     Expression_Ptr operator()(At_Root_Query_Ptr);
     Expression_Ptr operator()(Supports_Operator_Ptr);
@@ -72,14 +75,15 @@ namespace Sass {
     // these will return selectors
     Selector_List_Ptr operator()(Selector_List_Ptr);
     Selector_List_Ptr operator()(Complex_Selector_Ptr);
-    Attribute_Selector_Ptr operator()(Attribute_Selector_Ptr);
-    // they don't have any specific implementatio (yet)
-    Element_Selector_Ptr operator()(Element_Selector_Ptr s) { return s; };
-    Pseudo_Selector_Ptr operator()(Pseudo_Selector_Ptr s) { return s; };
-    Wrapped_Selector_Ptr operator()(Wrapped_Selector_Ptr s) { return s; };
-    Class_Selector_Ptr operator()(Class_Selector_Ptr s) { return s; };
-    Id_Selector_Ptr operator()(Id_Selector_Ptr s) { return s; };
-    Placeholder_Selector_Ptr operator()(Placeholder_Selector_Ptr s) { return s; };
+    Compound_Selector_Ptr operator()(Compound_Selector_Ptr);
+    Simple_Selector_Ptr operator()(Simple_Selector_Ptr s);
+    Wrapped_Selector_Ptr operator()(Wrapped_Selector_Ptr s);
+    // they don't have any specific implementation (yet)
+    // Element_Selector_Ptr operator()(Element_Selector_Ptr s) { return s; };
+    // Pseudo_Selector_Ptr operator()(Pseudo_Selector_Ptr s) { return s; };
+    // Class_Selector_Ptr operator()(Class_Selector_Ptr s) { return s; };
+    // Id_Selector_Ptr operator()(Id_Selector_Ptr s) { return s; };
+    // Placeholder_Selector_Ptr operator()(Placeholder_Selector_Ptr s) { return s; };
     // actual evaluated selectors
     Selector_List_Ptr operator()(Selector_Schema_Ptr);
     Expression_Ptr operator()(Parent_Selector_Ptr);
@@ -87,22 +91,12 @@ namespace Sass {
     template <typename U>
     Expression_Ptr fallback(U x) { return fallback_impl(x); }
 
-    // -- only need to define two comparisons, and the rest can be implemented in terms of them
-    static bool eq(Expression_Obj, Expression_Obj);
-    static bool lt(Expression_Obj, Expression_Obj, std::string op);
-    // -- arithmetic on the combinations that matter
-    static Value_Ptr op_numbers(enum Sass_OP, const Number&, const Number&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
-    static Value_Ptr op_number_color(enum Sass_OP, const Number&, const Color&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
-    static Value_Ptr op_color_number(enum Sass_OP, const Color&, const Number&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
-    static Value_Ptr op_colors(enum Sass_OP, const Color&, const Color&, struct Sass_Inspect_Options opt, ParserState* pstate = 0);
-    static Value_Ptr op_strings(Sass::Operand, Value&, Value&, struct Sass_Inspect_Options opt, ParserState* pstate = 0, bool interpolant = false);
-
   private:
     void interpolation(Context& ctx, std::string& res, Expression_Obj ex, bool into_quotes, bool was_itpl = false);
 
   };
 
-  Expression_Ptr cval_to_astnode(union Sass_Value* v, Backtrace* backtrace, ParserState pstate = ParserState("[AST]"));
+  Expression_Ptr cval_to_astnode(union Sass_Value* v, Backtraces traces, ParserState pstate = ParserState("[AST]"));
 
 }
 

data/ext/libsass/src/expand.cpp

@@ -9,14 +9,16 @@
 #include "backtrace.hpp"
 #include "context.hpp"
 #include "parser.hpp"
+#include "sass_functions.hpp"
 
 namespace Sass {
 
   // simple endless recursion protection
   const size_t maxRecursion = 500;
 
-  Expand::Expand(Context& ctx, Env* env, Backtrace* bt, std::vector<Selector_List_Obj>* stack)
+  Expand::Expand(Context& ctx, Env* env, std::vector<Selector_List_Obj>* stack)
   : ctx(ctx),
+    traces(ctx.traces),
     eval(Eval(*this)),
     recursions(0),
     in_keyframes(false),
@@ -26,8 +28,7 @@ namespace Sass {
     block_stack(std::vector<Block_Ptr>()),
     call_stack(std::vector<AST_Node_Obj>()),
     selector_stack(std::vector<Selector_List_Obj>()),
-    media_block_stack(std::vector<Media_Block_Ptr>()),
-    backtrace_stack(std::vector<Backtrace*>())
+    media_block_stack(std::vector<Media_Block_Ptr>())
   {
     env_stack.push_back(0);
     env_stack.push_back(env);
@@ -36,13 +37,6 @@ namespace Sass {
     if (stack == NULL) { selector_stack.push_back(0); }
     else { selector_stack.insert(selector_stack.end(), stack->begin(), stack->end()); }
     media_block_stack.push_back(0);
-    backtrace_stack.push_back(0);
-    backtrace_stack.push_back(bt);
-  }
-
-  Context& Expand::context()
-  {
-    return ctx;
   }
 
   Env* Expand::environment()
@@ -59,13 +53,6 @@ namespace Sass {
     return 0;
   }
 
-  Backtrace* Expand::backtrace()
-  {
-    if (backtrace_stack.size() > 0)
-      return backtrace_stack.back();
-    return 0;
-  }
-
   // blocks create new variable scopes
   Block_Ptr Expand::operator()(Block_Ptr b)
   {
@@ -78,7 +65,7 @@ namespace Sass {
                                 b->length(),
                                 b->is_root());
     // setup block and env stack
-    this->block_stack.push_back(&bb);
+    this->block_stack.push_back(bb);
     this->env_stack.push_back(&env);
     // operate on block
     // this may throw up!
@@ -95,12 +82,14 @@ namespace Sass {
     LOCAL_FLAG(old_at_root_without_rule, at_root_without_rule);
 
     if (in_keyframes) {
-      Block_Ptr bb = operator()(&r->block());
+      Block_Ptr bb = operator()(r->block());
       Keyframe_Rule_Obj k = SASS_MEMORY_NEW(Keyframe_Rule, r->pstate(), bb);
       if (r->selector()) {
-        selector_stack.push_back(0);
-        k->name(SASS_MEMORY_CAST_PTR(Selector_List, r->selector()->perform(&eval)));
-        selector_stack.pop_back();
+        if (Selector_List_Ptr s = r->selector()) {
+          selector_stack.push_back(0);
+          k->name(s->eval(eval));
+          selector_stack.pop_back();
+        }
       }
       return k.detach();
     }
@@ -108,50 +97,54 @@ namespace Sass {
     // reset when leaving scope
     LOCAL_FLAG(at_root_without_rule, false);
 
-    // do some special checks for the base level rules
-    if (r->is_root()) {
-      if (Selector_List_Ptr selector_list = SASS_MEMORY_CAST(Selector_List, r->selector())) {
+    // `&` is allowed in `@at-root`!
+    bool has_parent_selector = false;
+    for (size_t i = 0, L = selector_stack.size(); i < L && !has_parent_selector; i++) {
+      Selector_List_Obj ll = selector_stack.at(i);
+      has_parent_selector = ll != 0 && ll->length() > 0;
+    }
+
+    Selector_List_Obj sel = r->selector();
+    if (sel) sel = sel->eval(eval);
+
+    // check for parent selectors in base level rules
+    if (r->is_root() || (block_stack.back() && block_stack.back()->is_root())) {
+      if (Selector_List_Ptr selector_list = Cast<Selector_List>(r->selector())) {
         for (Complex_Selector_Obj complex_selector : selector_list->elements()) {
-          Complex_Selector_Ptr tail = &complex_selector;
+          Complex_Selector_Ptr tail = complex_selector;
           while (tail) {
             if (tail->head()) for (Simple_Selector_Obj header : tail->head()->elements()) {
-              if (SASS_MEMORY_CAST(Parent_Selector, header) == NULL) continue; // skip all others
+              Parent_Selector_Ptr ptr = Cast<Parent_Selector>(header);
+              if (ptr == NULL || (!ptr->real() || has_parent_selector)) continue;
               std::string sel_str(complex_selector->to_string(ctx.c_options));
-              error("Base-level rules cannot contain the parent-selector-referencing character '&'.", header->pstate(), backtrace());
+              error("Base-level rules cannot contain the parent-selector-referencing character '&'.", header->pstate(), traces);
             }
-            tail = &tail->tail();
+            tail = tail->tail();
           }
         }
       }
     }
-
-    Expression_Obj ex = 0;
-    if (r->selector()) ex = r->selector()->perform(&eval);
-    Selector_List_Obj sel = SASS_MEMORY_CAST(Selector_List, ex);
-    if (sel == 0) throw std::runtime_error("Expanded null selector");
-
-    if (sel->length() == 0 || sel->has_parent_ref()) {
-      bool has_parent_selector = false;
-      for (size_t i = 0, L = selector_stack.size(); i < L && !has_parent_selector; i++) {
-        Selector_List_Obj ll = selector_stack.at(i);
-        has_parent_selector = ll != 0 && ll->length() > 0;
-      }
-      if (sel->has_real_parent_ref() && !has_parent_selector) {
-        error("Base-level rules cannot contain the parent-selector-referencing character '&'.", sel->pstate(), backtrace());
+    else {
+      if (sel->length() == 0 || sel->has_parent_ref()) {
+        if (sel->has_real_parent_ref() && !has_parent_selector) {
+          error("Base-level rules cannot contain the parent-selector-referencing character '&'.", sel->pstate(), traces);
+        }
       }
     }
 
-    selector_stack.push_back(&sel);
+    // do not connect parent again
+    sel->remove_parent_selectors();
+    selector_stack.push_back(sel);
     Env env(environment());
     if (block_stack.back()->is_root()) {
       env_stack.push_back(&env);
     }
     sel->set_media_block(media_block_stack.back());
     Block_Obj blk = 0;
-    if (r->block()) blk = operator()(&r->block());
+    if (r->block()) blk = operator()(r->block());
     Ruleset_Ptr rr = SASS_MEMORY_NEW(Ruleset,
                                   r->pstate(),
-                                  &sel,
+                                  sel,
                                   blk);
     selector_stack.pop_back();
     if (block_stack.back()->is_root()) {
@@ -169,27 +162,33 @@ namespace Sass {
     Expression_Obj condition = f->condition()->perform(&eval);
     Supports_Block_Obj ff = SASS_MEMORY_NEW(Supports_Block,
                                        f->pstate(),
-                                       SASS_MEMORY_CAST(Supports_Condition, condition),
-                                       operator()(&f->block()));
+                                       Cast<Supports_Condition>(condition),
+                                       operator()(f->block()));
     return ff.detach();
   }
 
   Statement_Ptr Expand::operator()(Media_Block_Ptr m)
   {
-    media_block_stack.push_back(m);
-    Expression_Obj mq = m->media_queries()->perform(&eval);
+    Media_Block_Obj cpy = SASS_MEMORY_COPY(m);
+    // Media_Blocks are prone to have circular references
+    // Copy could leak memory if it does not get picked up
+    // Looks like we are able to reset block reference for copy
+    // Good as it will ensure a low memory overhead for this fix
+    // So this is a cheap solution with a minimal price
+    ctx.ast_gc.push_back(cpy); cpy->block(0);
+    Expression_Obj mq = eval(m->media_queries());
     std::string str_mq(mq->to_string(ctx.c_options));
     char* str = sass_copy_c_string(str_mq.c_str());
     ctx.strings.push_back(str);
-    Parser p(Parser::from_c_str(str, ctx, mq->pstate()));
-    mq = &p.parse_media_queries(); // re-assign now
-    List_Obj ls = SASS_MEMORY_CAST_PTR(List, mq->perform(&eval));
-    Block_Obj blk = operator()(&m->block());
+    Parser p(Parser::from_c_str(str, ctx, traces, mq->pstate()));
+    mq = p.parse_media_queries(); // re-assign now
+    cpy->media_queries(mq);
+    media_block_stack.push_back(cpy);
+    Block_Obj blk = operator()(m->block());
     Media_Block_Ptr mm = SASS_MEMORY_NEW(Media_Block,
                                       m->pstate(),
-                                      ls,
-                                      blk,
-                                      0);
+                                      mq,
+                                      blk);
     media_block_stack.pop_back();
     mm->tabs(m->tabs());
     return mm;
@@ -198,7 +197,7 @@ namespace Sass {
   Statement_Ptr Expand::operator()(At_Root_Block_Ptr a)
   {
     Block_Obj ab = a->block();
-    Expression_Obj ae = &a->expression();
+    Expression_Obj ae = a->expression();
 
     if (ae) ae = ae->perform(&eval);
     else ae = SASS_MEMORY_NEW(At_Root_Query, a->pstate());
@@ -208,23 +207,23 @@ namespace Sass {
 
                                        ;
 
-    Block_Obj bb = ab ? operator()(&ab) : NULL;
+    Block_Obj bb = ab ? operator()(ab) : NULL;
     At_Root_Block_Obj aa = SASS_MEMORY_NEW(At_Root_Block,
                                         a->pstate(),
                                         bb,
-                                        SASS_MEMORY_CAST(At_Root_Query, ae));
+                                        Cast<At_Root_Query>(ae));
     return aa.detach();
   }
 
   Statement_Ptr Expand::operator()(Directive_Ptr a)
   {
     LOCAL_FLAG(in_keyframes, a->is_keyframes());
-    Block_Ptr ab = &a->block();
-    Selector_Ptr as = &a->selector();
-    Expression_Ptr av = &a->value();
+    Block_Ptr ab = a->block();
+    Selector_List_Ptr as = a->selector();
+    Expression_Ptr av = a->value();
     selector_stack.push_back(0);
     if (av) av = av->perform(&eval);
-    if (as) as = SASS_MEMORY_CAST_PTR(Selector, as->perform(&eval));
+    if (as) as = eval(as);
     selector_stack.pop_back();
     Block_Ptr bb = ab ? operator()(ab) : NULL;
     Directive_Ptr aa = SASS_MEMORY_NEW(Directive,
@@ -241,14 +240,15 @@ namespace Sass {
     Block_Obj ab = d->block();
     String_Obj old_p = d->property();
     Expression_Obj prop = old_p->perform(&eval);
-    String_Obj new_p = SASS_MEMORY_CAST(String, prop);
+    String_Obj new_p = Cast<String>(prop);
     // we might get a color back
     if (!new_p) {
       std::string str(prop->to_string(ctx.c_options));
       new_p = SASS_MEMORY_NEW(String_Constant, old_p->pstate(), str);
     }
-    Expression_Obj value = d->value()->perform(&eval);
-    Block_Obj bb = ab ? operator()(&ab) : NULL;
+    Expression_Obj value = d->value();
+    if (value) value = value->perform(&eval);
+    Block_Obj bb = ab ? operator()(ab) : NULL;
     if (!bb) {
       if (!value || (value->is_invisible() && !d->is_important())) return 0;
     }
@@ -257,6 +257,7 @@ namespace Sass {
                                         new_p,
                                         value,
                                         d->is_important(),
+                                        d->is_custom_property(),
                                         bb);
     decl->tabs(d->tabs());
     return decl;
@@ -265,11 +266,11 @@ namespace Sass {
   Statement_Ptr Expand::operator()(Assignment_Ptr a)
   {
     Env* env = environment();
-    std::string var(a->variable());
+    const std::string& var(a->variable());
     if (a->is_global()) {
       if (a->is_default()) {
         if (env->has_global(var)) {
-          Expression_Obj e = SASS_MEMORY_CAST(Expression, env->get_global(var));
+          Expression_Obj e = Cast<Expression>(env->get_global(var));
           if (!e || e->concrete_type() == Expression::NULL_VAL) {
             env->set_global(var, a->value()->perform(&eval));
           }
@@ -288,7 +289,7 @@ namespace Sass {
         while (cur && cur->is_lexical()) {
           if (cur->has_local(var)) {
             if (AST_Node_Obj node = cur->get_local(var)) {
-              Expression_Obj e = SASS_MEMORY_CAST(Expression, node);
+              Expression_Obj e = Cast<Expression>(node);
               if (!e || e->concrete_type() == Expression::NULL_VAL) {
                 cur->set_local(var, a->value()->perform(&eval));
               }
@@ -304,7 +305,7 @@ namespace Sass {
       }
       else if (env->has_global(var)) {
         if (AST_Node_Obj node = env->get_global(var)) {
-          Expression_Obj e = SASS_MEMORY_CAST(Expression, node);
+          Expression_Obj e = Cast<Expression>(node);
           if (!e || e->concrete_type() == Expression::NULL_VAL) {
             env->set_global(var, a->value()->perform(&eval));
           }
@@ -328,7 +329,7 @@ namespace Sass {
     Import_Obj result = SASS_MEMORY_NEW(Import, imp->pstate());
     if (imp->import_queries() && imp->import_queries()->size()) {
       Expression_Obj ex = imp->import_queries()->perform(&eval);
-      result->import_queries(SASS_MEMORY_CAST(List, ex));
+      result->import_queries(Cast<List>(ex));
     }
     for ( size_t i = 0, S = imp->urls().size(); i < S; ++i) {
       result->urls().push_back(imp->urls()[i]->perform(&eval));
@@ -340,10 +341,11 @@ namespace Sass {
 
   Statement_Ptr Expand::operator()(Import_Stub_Ptr i)
   {
+    traces.push_back(Backtrace(i->pstate()));
     // get parent node from call stack
     AST_Node_Obj parent = call_stack.back();
-    if (SASS_MEMORY_CAST(Block, parent) == NULL) {
-      error("Import directives may not be used within control directives or mixins.", i->pstate());
+    if (Cast<Block>(parent) == NULL) {
+      error("Import directives may not be used within control directives or mixins.", i->pstate(), traces);
     }
     // we don't seem to need that actually afterall
     Sass_Import_Entry import = sass_make_import(
@@ -352,10 +354,18 @@ namespace Sass {
       0, 0
     );
     ctx.import_stack.push_back(import);
+
+    Block_Obj trace_block = SASS_MEMORY_NEW(Block, i->pstate());
+    Trace_Obj trace = SASS_MEMORY_NEW(Trace, i->pstate(), i->imp_path(), trace_block, 'i');
+    block_stack.back()->append(trace);
+    block_stack.push_back(trace_block);
+
     const std::string& abs_path(i->resource().abs_path);
-    append_block(&ctx.sheets.at(abs_path).root);
+    append_block(ctx.sheets.at(abs_path).root);
     sass_delete_import(ctx.import_stack.back());
     ctx.import_stack.pop_back();
+    block_stack.pop_back();
+    traces.pop_back();
     return 0;
   }
 
@@ -382,8 +392,13 @@ namespace Sass {
 
   Statement_Ptr Expand::operator()(Comment_Ptr c)
   {
+    if (ctx.output_style() == COMPRESSED) {
+      // comments should not be evaluated in compact
+      // https://github.com/sass/libsass/issues/2359
+      if (!c->is_important()) return NULL;
+    }
     eval.is_in_comment = true;
-    Comment_Ptr rv = SASS_MEMORY_NEW(Comment, c->pstate(), SASS_MEMORY_CAST_PTR(String, c->text()->perform(&eval)), c->is_important());
+    Comment_Ptr rv = SASS_MEMORY_NEW(Comment, c->pstate(), Cast<String>(c->text()->perform(&eval)), c->is_important());
     eval.is_in_comment = false;
     // TODO: eval the text, once we're parsing/storing it as a String_Schema
     return rv;
@@ -396,10 +411,10 @@ namespace Sass {
     call_stack.push_back(i);
     Expression_Obj rv = i->predicate()->perform(&eval);
     if (*rv) {
-      append_block(&i->block());
+      append_block(i->block());
     }
     else {
-      Block_Ptr alt = &i->alternative();
+      Block_Ptr alt = i->alternative();
       if (alt) append_block(alt);
     }
     call_stack.pop_back();
@@ -414,20 +429,22 @@ namespace Sass {
     std::string variable(f->variable());
     Expression_Obj low = f->lower_bound()->perform(&eval);
     if (low->concrete_type() != Expression::NUMBER) {
-      throw Exception::TypeMismatch(*low, "integer");
+      traces.push_back(Backtrace(low->pstate()));
+      throw Exception::TypeMismatch(traces, *low, "integer");
     }
     Expression_Obj high = f->upper_bound()->perform(&eval);
     if (high->concrete_type() != Expression::NUMBER) {
-      throw Exception::TypeMismatch(*high, "integer");
+      traces.push_back(Backtrace(high->pstate()));
+      throw Exception::TypeMismatch(traces, *high, "integer");
     }
-    Number_Obj sass_start = SASS_MEMORY_CAST(Number, low);
-    Number_Obj sass_end = SASS_MEMORY_CAST(Number, high);
+    Number_Obj sass_start = Cast<Number>(low);
+    Number_Obj sass_end = Cast<Number>(high);
     // check if units are valid for sequence
     if (sass_start->unit() != sass_end->unit()) {
       std::stringstream msg; msg << "Incompatible units: '"
         << sass_start->unit() << "' and '"
         << sass_end->unit() << "'.";
-      error(msg.str(), low->pstate(), backtrace());
+      error(msg.str(), low->pstate(), traces);
     }
     double start = sass_start->value();
     double end = sass_end->value();
@@ -435,17 +452,14 @@ namespace Sass {
     Env env(environment(), true);
     env_stack.push_back(&env);
     call_stack.push_back(f);
-    Number_Obj it = SASS_MEMORY_NEW(Number, low->pstate(), start, sass_end->unit());
-    env.set_local(variable, &it);
-    Block_Ptr body = &f->block();
+    Block_Ptr body = f->block();
     if (start < end) {
       if (f->is_inclusive()) ++end;
       for (double i = start;
            i < end;
            ++i) {
-        it = SASS_MEMORY_COPY(it);
-        it->value(i);
-        env.set_local(variable, &it);
+        Number_Obj it = SASS_MEMORY_NEW(Number, low->pstate(), i, sass_end->unit());
+        env.set_local(variable, it);
         append_block(body);
       }
     } else {
@@ -453,9 +467,8 @@ namespace Sass {
       for (double i = start;
            i > end;
            --i) {
-        it = SASS_MEMORY_COPY(it);
-        it->value(i);
-        env.set_local(variable, &it);
+        Number_Obj it = SASS_MEMORY_NEW(Number, low->pstate(), i, sass_end->unit());
+        env.set_local(variable, it);
         append_block(body);
       }
     }
@@ -473,25 +486,25 @@ namespace Sass {
     List_Obj list = 0;
     Map_Obj map;
     if (expr->concrete_type() == Expression::MAP) {
-      map = SASS_MEMORY_CAST(Map, expr);
+      map = Cast<Map>(expr);
     }
-    else if (Selector_List_Ptr ls = SASS_MEMORY_CAST(Selector_List, expr)) {
+    else if (Selector_List_Ptr ls = Cast<Selector_List>(expr)) {
       Listize listize;
       Expression_Obj rv = ls->perform(&listize);
-      list = SASS_MEMORY_CAST(List, rv);
+      list = Cast<List>(rv);
     }
     else if (expr->concrete_type() != Expression::LIST) {
       list = SASS_MEMORY_NEW(List, expr->pstate(), 1, SASS_COMMA);
       list->append(expr);
     }
     else {
-      list = SASS_MEMORY_CAST(List, expr);
+      list = Cast<List>(expr);
     }
     // remember variables and then reset them
     Env env(environment(), true);
     env_stack.push_back(&env);
     call_stack.push_back(e);
-    Block_Ptr body = &e->block();
+    Block_Ptr body = e->block();
 
     if (map) {
       for (auto key : map->keys()) {
@@ -502,43 +515,43 @@ namespace Sass {
           List_Obj variable = SASS_MEMORY_NEW(List, map->pstate(), 2, SASS_SPACE);
           variable->append(k);
           variable->append(v);
-          env.set_local(variables[0], &variable);
+          env.set_local(variables[0], variable);
         } else {
-          env.set_local(variables[0], &k);
-          env.set_local(variables[1], &v);
+          env.set_local(variables[0], k);
+          env.set_local(variables[1], v);
         }
         append_block(body);
       }
     }
     else {
       // bool arglist = list->is_arglist();
-      if (list->length() == 1 && SASS_MEMORY_CAST(Selector_List, list)) {
-        list = SASS_MEMORY_CAST(List, list);
+      if (list->length() == 1 && Cast<Selector_List>(list)) {
+        list = Cast<List>(list);
       }
       for (size_t i = 0, L = list->length(); i < L; ++i) {
-        Expression_Obj e = list->at(i);
+        Expression_Obj item = list->at(i);
         // unwrap value if the expression is an argument
-        if (Argument_Obj arg = SASS_MEMORY_CAST(Argument, e)) e = arg->value();
+        if (Argument_Obj arg = Cast<Argument>(item)) item = arg->value();
         // check if we got passed a list of args (investigate)
-        if (List_Obj scalars = SASS_MEMORY_CAST(List, e)) {
+        if (List_Obj scalars = Cast<List>(item)) {
           if (variables.size() == 1) {
             List_Obj var = scalars;
             // if (arglist) var = (*scalars)[0];
-            env.set_local(variables[0], &var);
+            env.set_local(variables[0], var);
           } else {
             for (size_t j = 0, K = variables.size(); j < K; ++j) {
               Expression_Obj res = j >= scalars->length()
                 ? SASS_MEMORY_NEW(Null, expr->pstate())
                 : (*scalars)[j]->perform(&eval);
-              env.set_local(variables[j], &res);
+              env.set_local(variables[j], res);
             }
           }
         } else {
           if (variables.size() > 0) {
-            env.set_local(variables.at(0), &e);
+            env.set_local(variables.at(0), item);
             for (size_t j = 1, K = variables.size(); j < K; ++j) {
               Expression_Obj res = SASS_MEMORY_NEW(Null, expr->pstate());
-              env.set_local(variables[j], &res);
+              env.set_local(variables[j], res);
             }
           }
         }
@@ -553,12 +566,12 @@ namespace Sass {
   Statement_Ptr Expand::operator()(While_Ptr w)
   {
     Expression_Obj pred = w->predicate();
-    Block_Ptr body = &w->block();
+    Block_Ptr body = w->block();
     Env env(environment(), true);
     env_stack.push_back(&env);
     call_stack.push_back(w);
     Expression_Obj cond = pred->perform(&eval);
-    while (*&cond) {
+    while (!cond->is_false()) {
       append_block(body);
       cond = pred->perform(&eval);
     }
@@ -569,21 +582,21 @@ namespace Sass {
 
   Statement_Ptr Expand::operator()(Return_Ptr r)
   {
-    error("@return may only be used within a function", r->pstate(), backtrace());
+    error("@return may only be used within a function", r->pstate(), traces);
     return 0;
   }
 
 
   void Expand::expand_selector_list(Selector_Obj s, Selector_List_Obj extender) {
 
-    if (Selector_List_Obj sl = SASS_MEMORY_CAST(Selector_List, s)) {
+    if (Selector_List_Obj sl = Cast<Selector_List>(s)) {
       for (Complex_Selector_Obj complex_selector : sl->elements()) {
         Complex_Selector_Obj tail = complex_selector;
         while (tail) {
           if (tail->head()) for (Simple_Selector_Obj header : tail->head()->elements()) {
-            if (SASS_MEMORY_CAST(Parent_Selector, header) == NULL) continue; // skip all others
+            if (Cast<Parent_Selector>(header) == NULL) continue; // skip all others
             std::string sel_str(complex_selector->to_string(ctx.c_options));
-            error("Can't extend " + sel_str + ": can't extend parent selectors", header->pstate(), backtrace());
+            error("Can't extend " + sel_str + ": can't extend parent selectors", header->pstate(), traces);
           }
           tail = tail->tail();
         }
@@ -591,20 +604,20 @@ namespace Sass {
     }
 
 
-    Selector_List_Obj contextualized = SASS_MEMORY_CAST_PTR(Selector_List, s->perform(&eval));
+    Selector_List_Obj contextualized = Cast<Selector_List>(s->perform(&eval));
     if (contextualized == false) return;
     for (auto complex_sel : contextualized->elements()) {
       Complex_Selector_Obj c = complex_sel;
       if (!c->head() || c->tail()) {
         std::string sel_str(contextualized->to_string(ctx.c_options));
-        error("Can't extend " + sel_str + ": can't extend nested selectors", c->pstate(), backtrace());
+        error("Can't extend " + sel_str + ": can't extend nested selectors", c->pstate(), traces);
       }
-      Compound_Selector_Obj placeholder = c->head();
-      if (contextualized->is_optional()) placeholder->is_optional(true);
+      Compound_Selector_Obj target = c->head();
+      if (contextualized->is_optional()) target->is_optional(true);
       for (size_t i = 0, L = extender->length(); i < L; ++i) {
         Complex_Selector_Obj sel = (*extender)[i];
         if (!(sel->head() && sel->head()->length() > 0 &&
-            SASS_MEMORY_CAST(Parent_Selector, (*sel->head())[0])))
+            Cast<Parent_Selector>((*sel->head())[0])))
         {
           Compound_Selector_Obj hh = SASS_MEMORY_NEW(Compound_Selector, (*extender)[i]->pstate());
           hh->media_block((*extender)[i]->media_block());
@@ -613,13 +626,13 @@ namespace Sass {
           if (sel->has_line_feed()) ssel->has_line_feed(true);
           Parent_Selector_Obj ps = SASS_MEMORY_NEW(Parent_Selector, (*extender)[i]->pstate());
           ps->media_block((*extender)[i]->media_block());
-          hh->append(&ps);
+          hh->append(ps);
           ssel->tail(sel);
           ssel->head(hh);
           sel = ssel;
         }
         // if (c->has_line_feed()) sel->has_line_feed(true);
-        ctx.subset_map.put(placeholder, std::make_pair(sel, placeholder));
+        ctx.subset_map.put(target, std::make_pair(sel, target));
       }
     }
 
@@ -627,31 +640,30 @@ namespace Sass {
 
   Statement* Expand::operator()(Extension_Ptr e)
   {
-    if (Selector_List_Obj extender = SASS_MEMORY_CAST(Selector_List, selector())) {
-      Selector_Obj s = e->selector();
-      Selector_List_Obj sl = NULL;
-      // check if we already have a valid selector list
-      if ((sl = SASS_MEMORY_CAST(Selector_List, s))) {}
-      // convert selector schema to a selector list
-      else if (Selector_Schema_Obj schema = SASS_MEMORY_CAST(Selector_Schema, s)) {
+    if (Selector_List_Ptr extender = selector()) {
+      Selector_List_Ptr sl = e->selector();
+      // abort on invalid selector
+      if (sl == NULL) return NULL;
+      if (Selector_Schema_Ptr schema = sl->schema()) {
         if (schema->has_real_parent_ref()) {
-          sl = eval(&schema);
+          // put root block on stack again (ignore parents)
+          // selector schema must not connect in eval!
+          block_stack.push_back(block_stack.at(1));
+          sl = eval(sl->schema());
+          block_stack.pop_back();
         } else {
           selector_stack.push_back(0);
-          sl = eval(&schema);
-          sl->remove_parent_selectors();
+          sl = eval(sl->schema());
           selector_stack.pop_back();
         }
       }
-      // abort on invalid selector
-      if (sl.isNull()) return NULL;
       for (Complex_Selector_Obj cs : sl->elements()) {
         if (!cs.isNull() && !cs->head().isNull()) {
           cs->head()->media_block(media_block_stack.back());
         }
       }
       selector_stack.push_back(0);
-      expand_selector_list(&sl, extender);
+      expand_selector_list(sl, extender);
       selector_stack.pop_back();
     }
     return 0;
@@ -662,7 +674,7 @@ namespace Sass {
     Env* env = environment();
     Definition_Obj dd = SASS_MEMORY_COPY(d);
     env->local_frame()[d->name() +
-                        (d->type() == Definition::MIXIN ? "[m]" : "[f]")] = &dd;
+                        (d->type() == Definition::MIXIN ? "[m]" : "[f]")] = dd;
 
     if (d->type() == Definition::FUNCTION && (
       Prelexer::calc_fn_call(d->name().c_str()) ||
@@ -671,9 +683,9 @@ namespace Sass {
       d->name() == "url"
     )) {
       deprecated(
-        "Naming a function \"" + d->name() + "\" is disallowed",
+        "Naming a function \"" + d->name() + "\" is disallowed and will be an error in future versions of Sass.",
         "This name conflicts with an existing CSS function with special parse rules.",
-         d->pstate()
+        false, d->pstate()
       );
     }
 
@@ -684,9 +696,8 @@ namespace Sass {
 
   Statement_Ptr Expand::operator()(Mixin_Call_Ptr c)
   {
-
     if (recursions > maxRecursion) {
-      throw Exception::StackError(*c);
+      throw Exception::StackError(traces, *c);
     }
 
     recursions ++;
@@ -694,19 +705,28 @@ namespace Sass {
     Env* env = environment();
     std::string full_name(c->name() + "[m]");
     if (!env->has(full_name)) {
-      error("no mixin named " + c->name(), c->pstate(), backtrace());
+      error("no mixin named " + c->name(), c->pstate(), traces);
     }
-    Definition_Obj def = SASS_MEMORY_CAST(Definition, (*env)[full_name]);
+    Definition_Obj def = Cast<Definition>((*env)[full_name]);
     Block_Obj body = def->block();
     Parameters_Obj params = def->parameters();
 
     if (c->block() && c->name() != "@content" && !body->has_content()) {
-      error("Mixin \"" + c->name() + "\" does not accept a content block.", c->pstate(), backtrace());
+      error("Mixin \"" + c->name() + "\" does not accept a content block.", c->pstate(), traces);
     }
     Expression_Obj rv = c->arguments()->perform(&eval);
-    Arguments_Obj args = SASS_MEMORY_CAST(Arguments, rv);
-    Backtrace new_bt(backtrace(), c->pstate(), ", in mixin `" + c->name() + "`");
-    backtrace_stack.push_back(&new_bt);
+    Arguments_Obj args = Cast<Arguments>(rv);
+    std::string msg(", in mixin `" + c->name() + "`");
+    traces.push_back(Backtrace(c->pstate(), msg));
+    ctx.callee_stack.push_back({
+      c->name().c_str(),
+      c->pstate().path,
+      c->pstate().line + 1,
+      c->pstate().column + 1,
+      SASS_CALLEE_MIXIN,
+      { env }
+    });
+
     Env new_env(def->environment());
     env_stack.push_back(&new_env);
     if (c->block()) {
@@ -718,7 +738,7 @@ namespace Sass {
                                           c->block(),
                                           Definition::MIXIN);
       thunk->environment(env);
-      new_env.local_frame()["@content[m]"] = &thunk;
+      new_env.local_frame()["@content[m]"] = thunk;
     }
 
     bind(std::string("Mixin"), c->name(), params, args, &ctx, &new_env, &eval);
@@ -726,16 +746,24 @@ namespace Sass {
     Block_Obj trace_block = SASS_MEMORY_NEW(Block, c->pstate());
     Trace_Obj trace = SASS_MEMORY_NEW(Trace, c->pstate(), c->name(), trace_block);
 
-
-    block_stack.push_back(&trace_block);
+    env->set_global("is_in_mixin", bool_true);
+    if (Block_Ptr pr = block_stack.back()) {
+      trace_block->is_root(pr->is_root());
+    }
+    block_stack.push_back(trace_block);
     for (auto bb : body->elements()) {
+      if (Ruleset_Ptr r = Cast<Ruleset>(bb)) {
+        r->is_root(trace_block->is_root());
+      }
       Statement_Obj ith = bb->perform(this);
       if (ith) trace->block()->append(ith);
     }
     block_stack.pop_back();
+    env->del_global("is_in_mixin");
 
+    ctx.callee_stack.pop_back();
     env_stack.pop_back();
-    backtrace_stack.pop_back();
+    traces.pop_back();
 
     recursions --;
     return trace.detach();
@@ -756,7 +784,7 @@ namespace Sass {
                                        "@content",
                                        SASS_MEMORY_NEW(Arguments, c->pstate()));
 
-    Trace_Obj trace = SASS_MEMORY_CAST_PTR(Trace, call->perform(this));
+    Trace_Obj trace = Cast<Trace>(call->perform(this));
 
     if (block_stack.back()->is_root()) {
       selector_stack.pop_back();
@@ -770,8 +798,8 @@ namespace Sass {
   {
     std::string err =std:: string("`Expand` doesn't handle ") + typeid(*n).name();
     String_Quoted_Obj msg = SASS_MEMORY_NEW(String_Quoted, ParserState("[WARN]"), err);
-    error("unknown internal error; please contact the LibSass maintainers", n->pstate(), backtrace());
-    return SASS_MEMORY_NEW(Warning, ParserState("[WARN]"), &msg);
+    error("unknown internal error; please contact the LibSass maintainers", n->pstate(), traces);
+    return SASS_MEMORY_NEW(Warning, ParserState("[WARN]"), msg);
   }
 
   // process and add to last block on stack
@@ -779,7 +807,7 @@ namespace Sass {
   {
     if (b->is_root()) call_stack.push_back(b);
     for (size_t i = 0, L = b->length(); i < L; ++i) {
-      Statement_Ptr stm = &b->at(i);
+      Statement_Ptr stm = b->at(i);
       Statement_Obj ith = stm->perform(this);
       if (ith) block_stack.back()->append(ith);
     }